\begin{code}
module MkIface (
mkModDetails, mkModDetailsFromIface, completeIface,
- writeIface, pprIface
+ writeIface, pprIface, pprUsage
) where
#include "HsVersions.h"
import HsCore ( HsIdInfo(..), UfExpr(..), toUfExpr, toUfBndr )
import HsTypes ( toHsTyVars )
import BasicTypes ( Fixity(..), NewOrData(..),
- Version, initialVersion, bumpVersion, isLoopBreaker
+ Version, initialVersion, bumpVersion,
)
import RnMonad
import RnHsSyn ( RenamedInstDecl, RenamedTyClDecl )
TyThing(..), DFunId, TypeEnv, Avails,
WhatsImported(..), GenAvailInfo(..),
ImportVersion, AvailInfo, Deprecations(..),
- extendTypeEnvList
+ extendTypeEnvList, lookupVersion,
)
import CmdLineOpts
-import Id ( Id, idType, idInfo, omitIfaceSigForId, isDictFunId,
- idSpecialisation, setIdInfo, isLocalId, idName, hasNoBinding
+import Id ( idType, idInfo, isImplicitId, isDictFunId,
+ idSpecialisation, isLocalId, idName, hasNoBinding
)
import Var ( isId )
import VarSet
import SrcLoc ( noSrcLoc )
import Outputable
import Module ( ModuleName )
+import Maybes ( orElse )
import IO ( IOMode(..), openFile, hClose )
\end{code}
\begin{code}
mkModDetails :: TypeEnv -- From typechecker
-> [CoreBind] -- Final bindings
- -> [Id] -- Top-level Ids from the code generator;
-- they have authoritative arity info
-> [IdCoreRule] -- Tidy orphan rules
-> ModDetails
-mkModDetails type_env tidy_binds stg_ids orphan_rules
+mkModDetails type_env tidy_binds orphan_rules
= ModDetails { md_types = new_type_env,
md_rules = rule_dcls,
md_insts = filter isDictFunId final_ids }
keep_it (AnId id) = hasNoBinding id
keep_it other = True
- stg_id_set = mkVarSet stg_ids
- final_ids = [addStgInfo stg_id_set id | bind <- tidy_binds
- , id <- bindersOf bind
- , isGlobalName (idName id)]
+ final_ids = [id | bind <- tidy_binds
+ , id <- bindersOf bind
+ , isGlobalName (idName id)]
-- The complete rules are gotten by combining
-- a) the orphan rules
-- All the rules from an interface are of the IfaceRuleOut form
\end{code}
-
-We have to add on the arity and CAF info computed by the code generator
-This is also the moment at which we may forget that this function has
-a worker: see the comments below
-
-\begin{code}
-addStgInfo :: IdSet -- Ids used at code-gen time; they have better pragma info!
- -> Id -> Id
-addStgInfo stg_ids id
- = id `setIdInfo` final_idinfo
- where
- idinfo = idInfo id
- idinfo' = idinfo `setArityInfo` stg_arity
- `setCafInfo` cafInfo stg_idinfo
- final_idinfo | worker_ok = idinfo'
- | otherwise = idinfo' `setWorkerInfo` NoWorker
-
- stg_idinfo = case lookupVarSet stg_ids id of
- Just id' -> idInfo id'
- Nothing -> pprTrace "ifaceBinds not found:" (ppr id) $
- idInfo id
-
- stg_arity = arityInfo stg_idinfo
-
- ------------ Worker --------------
- -- We only treat a function as having a worker if
- -- the exported arity (which is now the number of visible lambdas)
- -- is the same as the arity at the moment of the w/w split
- -- If so, we can safely omit the unfolding inside the wrapper, and
- -- instead re-generate it from the type/arity/strictness info
- -- But if the arity has changed, we just take the simple path and
- -- put the unfolding into the interface file, forgetting the fact
- -- that it's a wrapper.
- --
- -- How can this happen? Sometimes we get
- -- f = coerce t (\x y -> $wf x y)
- -- at the moment of w/w split; but the eta reducer turns it into
- -- f = coerce t $wf
- -- which is perfectly fine except that the exposed arity so far as
- -- the code generator is concerned (zero) differs from the arity
- -- when we did the split (2).
- --
- -- All this arises because we use 'arity' to mean "exactly how many
- -- top level lambdas are there" in interface files; but during the
- -- compilation of this module it means "how many things can I apply
- -- this to".
- worker_ok = case workerInfo idinfo of
- NoWorker -> True
- HasWorker work_id wrap_arity -> wrap_arity == arityLowerBound stg_arity
-\end{code}
-
-
\begin{code}
getRules :: [IdCoreRule] -- Orphan rules
-> [CoreBind] -- Bindings, with rules in the top-level Ids
= ([getName field_label], mk_bang_ty strict_mark (fieldLabelType field_label))
ifaceTyCls (AnId id) so_far
- | omitIfaceSigForId id = so_far
- | otherwise = iface_sig : so_far
+ | isImplicitId id = so_far
+ | otherwise = iface_sig : so_far
where
iface_sig = IfaceSig { tcdName = getName id,
tcdType = toHsType id_type,
NoStrictnessInfo -> []
info -> [HsStrictness info]
-
------------ Worker --------------
work_info = workerInfo id_info
has_worker = case work_info of { HasWorker _ _ -> True; other -> False }
-- No old interface, so definitely write a new one!
= (new_iface, Just (text "No old interface available"))
-addVersionInfo (Just old_iface@(ModIface { mi_version = old_version,
- mi_decls = old_decls,
- mi_fixities = old_fixities }))
- new_iface@(ModIface { mi_decls = new_decls,
- mi_fixities = new_fixities })
+addVersionInfo (Just old_iface@(ModIface { mi_version = old_version,
+ mi_decls = old_decls,
+ mi_fixities = old_fixities,
+ mi_deprecs = old_deprecs }))
+ new_iface@(ModIface { mi_decls = new_decls,
+ mi_fixities = new_fixities,
+ mi_deprecs = new_deprecs })
| no_output_change && no_usage_change
= (new_iface, Nothing)
| otherwise -- Add updated version numbers
= --pprTrace "completeIface" (ppr (dcl_tycl old_decls))
- (final_iface, Just pp_tc_diffs)
+ (final_iface, Just pp_diffs)
where
final_iface = new_iface { mi_version = new_version }
- new_version = VersionInfo { vers_module = bumpVersion no_output_change (vers_module old_version),
+ old_mod_vers = vers_module old_version
+ new_version = VersionInfo { vers_module = bumpVersion no_output_change old_mod_vers,
vers_exports = bumpVersion no_export_change (vers_exports old_version),
vers_rules = bumpVersion no_rule_change (vers_rules old_version),
vers_decls = tc_vers }
- no_output_change = no_tc_change && no_rule_change && no_export_change
+ no_output_change = no_tc_change && no_rule_change && no_export_change && no_deprec_change
no_usage_change = mi_usages old_iface == mi_usages new_iface
no_export_change = mi_exports old_iface == mi_exports new_iface -- Kept sorted
no_rule_change = dcl_rules old_decls == dcl_rules new_decls -- Ditto
+ no_deprec_change = old_deprecs == new_deprecs
-- Fill in the version number on the new declarations by looking at the old declarations.
-- Set the flag if anything changes.
-- Assumes that the decls are sorted by hsDeclName.
- old_vers_decls = vers_decls old_version
- (no_tc_change, pp_tc_diffs, tc_vers) = diffDecls old_vers_decls old_fixities new_fixities
+ (no_tc_change, pp_tc_diffs, tc_vers) = diffDecls old_version old_fixities new_fixities
(dcl_tycl old_decls) (dcl_tycl new_decls)
-
-
-
-diffDecls :: NameEnv Version -- Old version map
+ pp_diffs = vcat [pp_tc_diffs,
+ pp_change no_export_change "Export list",
+ pp_change no_rule_change "Rules",
+ pp_change no_deprec_change "Deprecations",
+ pp_change no_usage_change "Usages"]
+ pp_change True what = empty
+ pp_change False what = text what <+> ptext SLIT("changed")
+
+diffDecls :: VersionInfo -- Old version
-> NameEnv Fixity -> NameEnv Fixity -- Old and new fixities
-> [RenamedTyClDecl] -> [RenamedTyClDecl] -- Old and new decls
-> (Bool, -- True <=> no change
SDoc, -- Record of differences
- NameEnv Version) -- New version
+ NameEnv Version) -- New version map
-diffDecls old_vers old_fixities new_fixities old new
+diffDecls (VersionInfo { vers_module = old_mod_vers, vers_decls = old_decls_vers })
+ old_fixities new_fixities old new
= diff True empty emptyNameEnv old new
where
-- When seeing if two decls are the same,
same_fixity n = lookupNameEnv old_fixities n == lookupNameEnv new_fixities n
diff ok_so_far pp new_vers [] [] = (ok_so_far, pp, new_vers)
- diff ok_so_far pp new_vers (od:ods) [] = diff False (pp $$ only_old od) new_vers ods []
- diff ok_so_far pp new_vers [] (nd:nds) = diff False (pp $$ only_new nd) new_vers [] nds
+ diff ok_so_far pp new_vers (od:ods) [] = diff False (pp $$ only_old od) new_vers ods []
+ diff ok_so_far pp new_vers [] (nd:nds) = diff False (pp $$ only_new nd) new_vers_with_new [] nds
+ where
+ new_vers_with_new = extendNameEnv new_vers (tyClDeclName nd) (bumpVersion False old_mod_vers)
+ -- When adding a new item, start from the old module version
+ -- This way, if you have version 4 of f, then delete f, then add f again,
+ -- you'll get version 6 of f, which will (correctly) force recompilation of
+ -- clients
+
diff ok_so_far pp new_vers (od:ods) (nd:nds)
= case od_name `compare` nd_name of
LT -> diff False (pp $$ only_old od) new_vers ods (nd:nds)
GT -> diff False (pp $$ only_new nd) new_vers (od:ods) nds
- EQ | od `eq_tc` nd -> diff ok_so_far pp new_vers ods nds
- | otherwise -> diff False (pp $$ changed od nd) new_vers' ods nds
+ EQ | od `eq_tc` nd -> diff ok_so_far pp new_vers ods nds
+ | otherwise -> diff False (pp $$ changed od nd) new_vers_with_diff ods nds
where
od_name = tyClDeclName od
nd_name = tyClDeclName nd
- new_vers' = extendNameEnv new_vers nd_name
- (bumpVersion False (lookupNameEnv_NF old_vers od_name))
+ new_vers_with_diff = extendNameEnv new_vers nd_name (bumpVersion False old_version)
+ old_version = lookupVersion old_decls_vers od_name
- only_old d = ptext SLIT("Only in old iface:") <+> ppr d
- only_new d = ptext SLIT("Only in new iface:") <+> ppr d
- changed d nd = ptext SLIT("Changed in iface: ") <+> ((ptext SLIT("Old:") <+> ppr d) $$
- (ptext SLIT("New:") <+> ppr nd))
+ only_old d = ptext SLIT("Only in old iface:") <+> ppr d
+ only_new d = ptext SLIT("Only in new iface:") <+> ppr d
+ changed od nd = ptext SLIT("Changed in iface: ") <+> ((ptext SLIT("Old:") <+> ppr od) $$
+ (ptext SLIT("New:") <+> ppr nd))
\end{code}
, pprFixities (mi_fixities iface) (dcl_tycl decls)
, pprIfaceDecls (vers_decls version_info) decls
- , pprDeprecs (mi_deprecs iface)
+ , pprRulesAndDeprecs (dcl_rules decls) (mi_deprecs iface)
]
where
version_info = mi_version iface
pprIfaceDecls version_map decls
= vcat [ vcat [ppr i <+> semi | i <- dcl_insts decls]
, vcat (map ppr_decl (dcl_tycl decls))
- , pprRules (dcl_rules decls)
]
where
ppr_decl d = ppr_vers d <+> ppr d <> semi
(n,_) <- tyClDeclNames d,
Just fix <- [lookupNameEnv fixity_map n]] <> semi
-pprRules [] = empty
-pprRules rules = hsep [ptext SLIT("{-## __R"), vcat (map ppr rules), ptext SLIT("##-}")]
-
-pprDeprecs NoDeprecs = empty
-pprDeprecs deprecs = ptext SLIT("{-## __D") <+> guts <+> ptext SLIT("##-}")
- where
- guts = case deprecs of
- DeprecAll txt -> doubleQuotes (ptext txt)
- DeprecSome env -> pp_deprecs env
-
-pp_deprecs env = vcat (punctuate semi (map pp_deprec (nameEnvElts env)))
- where
- pp_deprec (name, txt) = pprOcc name <+> doubleQuotes (ptext txt)
+-- Disgusting to print these two together, but that's
+-- the way the interface parser currently expects them.
+pprRulesAndDeprecs [] NoDeprecs = empty
+pprRulesAndDeprecs rules deprecs
+ = ptext SLIT("{-##") <+> (pp_rules rules $$ pp_deprecs deprecs) <+> ptext SLIT("##-}")
+ where
+ pp_rules [] = empty
+ pp_rules rules = ptext SLIT("__R") <+> vcat (map ppr rules)
+
+ pp_deprecs NoDeprecs = empty
+ pp_deprecs deprecs = ptext SLIT("__D") <+> guts
+ where
+ guts = case deprecs of
+ DeprecAll txt -> doubleQuotes (ptext txt)
+ DeprecSome env -> ppr_deprec_env env
+
+ppr_deprec_env env = vcat (punctuate semi (map pp_deprec (nameEnvElts env)))
+ where
+ pp_deprec (name, txt) = pprOcc name <+> doubleQuotes (ptext txt)
\end{code}