\begin{code}
module Desugar ( deSugar, deSugarExpr ) where
-#include "HsVersions.h"
-
import DynFlags
import StaticFlags
import HscTypes
import DsExpr () -- Forces DsExpr to be compiled; DsBinds only
-- depends on DsExpr.hi-boot.
import Module
-import UniqFM
-import PackageConfig
import RdrName
import NameSet
import VarSet
import CoreLint
import CoreFVs
import ErrUtils
-import ListSetOps
import Outputable
import SrcLoc
import Maybes
import FastString
-import Util
import Coverage
-import IOEnv
-import Data.IORef
+import Data.IORef
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-deSugar :: HscEnv -> ModLocation -> TcGblEnv -> IO (Maybe ModGuts)
+-- | Main entry point to the desugarer.
+deSugar :: HscEnv -> ModLocation -> TcGblEnv -> IO (Messages, Maybe ModGuts)
-- Can modify PCS by faulting in more declarations
deSugar hsc_env
tcg_type_env = type_env,
tcg_imports = imports,
tcg_exports = exports,
- tcg_dus = dus,
- tcg_inst_uses = dfun_uses_var,
- tcg_th_used = th_var,
tcg_keep = keep_var,
tcg_rdr_env = rdr_env,
tcg_fix_env = fix_env,
+ tcg_inst_env = inst_env,
tcg_fam_inst_env = fam_inst_env,
- tcg_deprecs = deprecs,
+ tcg_warns = warns,
+ tcg_anns = anns,
tcg_binds = binds,
tcg_fords = fords,
tcg_rules = rules,
tcg_insts = insts,
- tcg_fam_insts = fam_insts })
+ tcg_fam_insts = fam_insts,
+ tcg_hpc = other_hpc_info })
= do { let dflags = hsc_dflags hsc_env
; showPass dflags "Desugar"
-- Desugar the program
; let export_set = availsToNameSet exports
- ; let auto_scc = mkAutoScc mod export_set
- ; let noDbgSites = []
+ ; let auto_scc = mkAutoScc dflags mod export_set
; let target = hscTarget dflags
- ; mb_res <- case target of
- HscNothing -> return (Just ([], [], NoStubs, noHpcInfo, noDbgSites))
- _ -> do (binds_cvr,ds_hpc_info)
- <- if opt_Hpc
- then addCoverageTicksToBinds dflags mod mod_loc binds
- else return (binds, noHpcInfo)
- initDs hsc_env mod rdr_env type_env $ do
- { core_prs <- dsTopLHsBinds auto_scc binds_cvr
- ; (ds_fords, foreign_prs) <- dsForeigns fords
- ; let all_prs = foreign_prs ++ core_prs
- local_bndrs = mkVarSet (map fst all_prs)
- ; ds_rules <- mappM (dsRule mod local_bndrs) rules
- ; return (all_prs, catMaybes ds_rules, ds_fords, ds_hpc_info)
- ; dbgSites_var <- getBkptSitesDs
- ; dbgSites <- ioToIOEnv$ readIORef dbgSites_var
- ; return (all_prs, catMaybes ds_rules, ds_fords, ds_hpc_info, dbgSites)
- }
+ ; let hpcInfo = emptyHpcInfo other_hpc_info
+ ; (msgs, mb_res)
+ <- case target of
+ HscNothing ->
+ return (emptyMessages,
+ Just ([], [], NoStubs, hpcInfo, emptyModBreaks))
+ _ -> do
+ (binds_cvr,ds_hpc_info, modBreaks)
+ <- if (opt_Hpc
+ || target == HscInterpreted)
+ && (not (isHsBoot hsc_src))
+ then addCoverageTicksToBinds dflags mod mod_loc (typeEnvTyCons type_env) binds
+ else return (binds, hpcInfo, emptyModBreaks)
+ initDs hsc_env mod rdr_env type_env $ do
+ core_prs <- dsTopLHsBinds auto_scc binds_cvr
+ (ds_fords, foreign_prs) <- dsForeigns fords
+ let all_prs = foreign_prs ++ core_prs
+ ds_rules <- mapM dsRule rules
+ return (all_prs, catMaybes ds_rules, ds_fords, ds_hpc_info, modBreaks)
+
; case mb_res of {
- Nothing -> return Nothing ;
- Just (all_prs, ds_rules, ds_fords,ds_hpc_info, dbgSites) -> do
+ Nothing -> return (msgs, Nothing) ;
+ Just (all_prs, ds_rules, ds_fords,ds_hpc_info, modBreaks) -> do
{ -- Add export flags to bindings
keep_alive <- readIORef keep_var
; doIfSet (dopt Opt_D_dump_ds dflags)
(printDump (ppr_ds_rules ds_rules))
- ; dfun_uses <- readIORef dfun_uses_var -- What dfuns are used
- ; th_used <- readIORef th_var -- Whether TH is used
- ; let used_names = allUses dus `unionNameSets` dfun_uses
- pkgs | th_used = insertList thPackageId (imp_dep_pkgs imports)
- | otherwise = imp_dep_pkgs imports
-
- dep_mods = eltsUFM (delFromUFM (imp_dep_mods imports) (moduleName mod))
- -- M.hi-boot can be in the imp_dep_mods, but we must remove
- -- it before recording the modules on which this one depends!
- -- (We want to retain M.hi-boot in imp_dep_mods so that
- -- loadHiBootInterface can see if M's direct imports depend
- -- on M.hi-boot, and hence that we should do the hi-boot consistency
- -- check.)
-
- dir_imp_mods = imp_mods imports
-
- ; usages <- mkUsageInfo hsc_env dir_imp_mods dep_mods used_names
-
- ; let
- -- Modules don't compare lexicographically usually,
- -- but we want them to do so here.
- le_mod :: Module -> Module -> Bool
- le_mod m1 m2 = moduleNameFS (moduleName m1)
- <= moduleNameFS (moduleName m2)
- le_dep_mod :: (ModuleName, IsBootInterface) -> (ModuleName, IsBootInterface) -> Bool
- le_dep_mod (m1,_) (m2,_) = moduleNameFS m1 <= moduleNameFS m2
-
- deps = Deps { dep_mods = sortLe le_dep_mod dep_mods,
- dep_pkgs = sortLe (<=) pkgs,
- dep_orphs = sortLe le_mod (imp_orphs imports),
- dep_finsts = sortLe le_mod (imp_finsts imports) }
- -- sort to get into canonical order
-
- mod_guts = ModGuts {
+ ; used_names <- mkUsedNames tcg_env
+ ; deps <- mkDependencies tcg_env
+
+ ; let mod_guts = ModGuts {
mg_module = mod,
mg_boot = isHsBoot hsc_src,
mg_exports = exports,
mg_deps = deps,
- mg_usages = usages,
- mg_dir_imps = [m | (m,_,_) <- moduleEnvElts dir_imp_mods],
+ mg_used_names = used_names,
+ mg_dir_imps = imp_mods imports,
mg_rdr_env = rdr_env,
mg_fix_env = fix_env,
- mg_deprecs = deprecs,
+ mg_warns = warns,
+ mg_anns = anns,
mg_types = type_env,
mg_insts = insts,
mg_fam_insts = fam_insts,
+ mg_inst_env = inst_env,
mg_fam_inst_env = fam_inst_env,
mg_rules = ds_rules,
mg_binds = ds_binds,
mg_foreign = ds_fords,
mg_hpc_info = ds_hpc_info,
- mg_dbg_sites = dbgSites }
- ; return (Just mod_guts)
+ mg_modBreaks = modBreaks,
+ mg_vect_info = noVectInfo
+ }
+ ; return (msgs, Just mod_guts)
}}}
-mkAutoScc :: Module -> NameSet -> AutoScc
-mkAutoScc mod exports
+mkAutoScc :: DynFlags -> Module -> NameSet -> AutoScc
+mkAutoScc dflags mod exports
| not opt_SccProfilingOn -- No profiling
= NoSccs
- | opt_AutoSccsOnAllToplevs -- Add auto-scc on all top-level things
- = AddSccs mod (\id -> True)
- | opt_AutoSccsOnExportedToplevs -- Only on exported things
+ -- Add auto-scc on all top-level things
+ | dopt Opt_AutoSccsOnAllToplevs dflags
+ = AddSccs mod (\id -> not $ isDerivedOccName $ getOccName id)
+ -- See #1641. This is pretty yucky, but I can't see a better way
+ -- to identify compiler-generated Ids, and at least this should
+ -- catch them all.
+ -- Only on exported things
+ | dopt Opt_AutoSccsOnExportedToplevs dflags
= AddSccs mod (\id -> idName id `elemNameSet` exports)
| otherwise
= NoSccs
-
deSugarExpr :: HscEnv
-> Module -> GlobalRdrEnv -> TypeEnv
-> LHsExpr Id
- -> IO (Maybe CoreExpr)
+ -> IO (Messages, Maybe CoreExpr)
-- Prints its own errors; returns Nothing if error occurred
-deSugarExpr hsc_env this_mod rdr_env type_env tc_expr
- = do { let dflags = hsc_dflags hsc_env
- ; showPass dflags "Desugar"
+deSugarExpr hsc_env this_mod rdr_env type_env tc_expr = do
+ let dflags = hsc_dflags hsc_env
+ showPass dflags "Desugar"
- -- Do desugaring
- ; mb_core_expr <- initDs hsc_env this_mod rdr_env type_env $
- dsLExpr tc_expr
+ -- Do desugaring
+ (msgs, mb_core_expr) <- initDs hsc_env this_mod rdr_env type_env $
+ dsLExpr tc_expr
- ; case mb_core_expr of {
- Nothing -> return Nothing ;
- Just expr -> do {
+ case mb_core_expr of
+ Nothing -> return (msgs, Nothing)
+ Just expr -> do
- -- Dump output
- dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
+ -- Dump output
+ dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
- ; return (Just expr) } } }
+ return (msgs, Just expr)
-- addExportFlags
-- Set the no-discard flag if either
-- it's just because the type checker is rather busy already and
-- I didn't want to pass in yet another mapping.
+addExportFlags :: HscTarget -> NameSet -> NameSet -> [(Id, t)] -> [CoreRule]
+ -> [(Id, t)]
addExportFlags target exports keep_alive prs rules
= [(add_export bndr, rhs) | (bndr,rhs) <- prs]
where
is_exported | target == HscInterpreted = isExternalName
| otherwise = (`elemNameSet` exports)
+ppr_ds_rules :: [CoreRule] -> SDoc
ppr_ds_rules [] = empty
ppr_ds_rules rules
= text "" $$ text "-------------- DESUGARED RULES -----------------" $$
%************************************************************************
\begin{code}
-dsRule :: Module -> IdSet -> LRuleDecl Id -> DsM (Maybe CoreRule)
-dsRule mod in_scope (L loc (HsRule name act vars lhs tv_lhs rhs fv_rhs))
+dsRule :: LRuleDecl Id -> DsM (Maybe CoreRule)
+dsRule (L loc (HsRule name act vars lhs _tv_lhs rhs _fv_rhs))
= putSrcSpanDs loc $
- do { let bndrs = [var | RuleBndr (L _ var) <- vars]
+ do { let bndrs' = [var | RuleBndr (L _ var) <- vars]
; lhs' <- dsLExpr lhs
; rhs' <- dsLExpr rhs
- ; case decomposeRuleLhs bndrs lhs' of {
- Nothing -> do { warnDs msg; return Nothing } ;
- Just (bndrs', fn_id, args) -> do
-
-- Substitute the dict bindings eagerly,
-- and take the body apart into a (f args) form
+ ; case decomposeRuleLhs (mkLams bndrs' lhs') of {
+ Nothing -> do { warnDs msg; return Nothing } ;
+ Just (bndrs, fn_id, args) -> do
+
{ let local_rule = isLocalId fn_id
-- NB: isLocalId is False of implicit Ids. This is good becuase
-- we don't want to attach rules to the bindings of implicit Ids,
fn_name = idName fn_id
rule = Rule { ru_name = name, ru_fn = fn_name, ru_act = act,
- ru_bndrs = bndrs', ru_args = args, ru_rhs = rhs',
+ ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs',
ru_rough = roughTopNames args,
ru_local = local_rule }
; return (Just rule)
} } }
where
- msg = hang (ptext SLIT("RULE left-hand side too complicated to desugar; ignored"))
+ msg = hang (ptext (sLit "RULE left-hand side too complicated to desugar; ignored"))
2 (ppr lhs)
\end{code}