compiler/deSugar/Desugar.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   4 %
   5
   6 The Desugarer: turning HsSyn into Core.
   7
   8 \begin{code}
   9 module Desugar ( deSugar, deSugarExpr ) where
  10
  11 #include "HsVersions.h"
  12
  13 import Breakpoints
  14 import DynFlags
  15 import StaticFlags
  16 import HscTypes
  17 import HsSyn
  18 import TcRnTypes
  19 import MkIface
  20 import Id
  21 import Name
  22 import CoreSyn
  23 import PprCore
  24 import DsMonad
  25 import DsExpr
  26 import DsBinds
  27 import DsForeign
  28 import DsExpr           ()      -- Forces DsExpr to be compiled; DsBinds only
  29                                 -- depends on DsExpr.hi-boot.
  30 import Module
  31 import UniqFM
  32 import PackageConfig
  33 import RdrName
  34 import NameSet
  35 import VarSet
  36 import Rules
  37 import CoreLint
  38 import CoreFVs
  39 import ErrUtils
  40 import ListSetOps
  41 import Outputable
  42 import SrcLoc
  43 import Maybes
  44 import FastString
  45 import Util
  46 import Coverage
  47 import IOEnv
  48 import Data.IORef
  49
  50 \end{code}
  51
  52 %************************************************************************
  53 %*                                                                      *
  54 %*              The main function: deSugar
  55 %*                                                                      *
  56 %************************************************************************
  57
  58 \begin{code}
  59 deSugar :: HscEnv -> ModLocation -> TcGblEnv -> IO (Maybe ModGuts)
  60 -- Can modify PCS by faulting in more declarations
  61
  62 deSugar hsc_env
  63         mod_loc
  64         tcg_env@(TcGblEnv { tcg_mod       = mod,
  65                             tcg_src       = hsc_src,
  66                             tcg_type_env  = type_env,
  67                             tcg_imports   = imports,
  68                             tcg_exports   = exports,
  69                             tcg_dus       = dus,
  70                             tcg_inst_uses = dfun_uses_var,
  71                             tcg_th_used   = th_var,
  72                             tcg_keep      = keep_var,
  73                             tcg_rdr_env   = rdr_env,
  74                             tcg_fix_env   = fix_env,
  75                             tcg_deprecs   = deprecs,
  76                             tcg_binds     = binds,
  77                             tcg_fords     = fords,
  78                             tcg_rules     = rules,
  79                             tcg_insts     = insts,
  80                             tcg_fam_insts = fam_insts })
  81   = do  { showPass dflags "Desugar"
  82
  83         -- Desugar the program
  84         ; let export_set = availsToNameSet exports
  85         ; let auto_scc = mkAutoScc mod export_set
  86         ; let noDbgSites = []
  87         ; mb_res <- case ghcMode dflags of
  88                      JustTypecheck -> return (Just ([], [], NoStubs, noHpcInfo, noDbgSites))
  89                      _        -> do (binds_cvr,ds_hpc_info)
  90                                               <- if opt_Hpc
  91                                                  then addCoverageTicksToBinds dflags mod mod_loc binds
  92                                                  else return (binds, noHpcInfo)
  93                                     initDs hsc_env mod rdr_env type_env $ do
  94                                         { core_prs <- dsTopLHsBinds auto_scc binds_cvr
  95                                         ; (ds_fords, foreign_prs) <- dsForeigns fords
  96                                         ; let all_prs = foreign_prs ++ core_prs
  97                                               local_bndrs = mkVarSet (map fst all_prs)
  98                                         ; ds_rules <- mappM (dsRule mod local_bndrs) rules
  99                                         ; return (all_prs, catMaybes ds_rules, ds_fords, ds_hpc_info)
 100                                         ; dbgSites_var <- getBkptSitesDs
 101                                         ; dbgSites <- ioToIOEnv$ readIORef dbgSites_var
 102                                         ; return (all_prs, catMaybes ds_rules, ds_fords, ds_hpc_info, dbgSites)
 103                                         }
 104         ; case mb_res of {
 105            Nothing -> return Nothing ;
 106            Just (all_prs, ds_rules, ds_fords,ds_hpc_info, dbgSites) -> do
 107
 108         {       -- Add export flags to bindings
 109           keep_alive <- readIORef keep_var
 110         ; let final_prs = addExportFlags ghci_mode export_set
 111                                  keep_alive all_prs ds_rules
 112               ds_binds  = [Rec final_prs]
 113         -- Notice that we put the whole lot in a big Rec, even the foreign binds
 114         -- When compiling PrelFloat, which defines data Float = F# Float#
 115         -- we want F# to be in scope in the foreign marshalling code!
 116         -- You might think it doesn't matter, but the simplifier brings all top-level
 117         -- things into the in-scope set before simplifying; so we get no unfolding for F#!
 118
 119         -- Lint result if necessary
 120         ; endPass dflags "Desugar" Opt_D_dump_ds ds_binds
 121
 122         -- Dump output
 123         ; doIfSet (dopt Opt_D_dump_ds dflags)
 124                   (printDump (ppr_ds_rules ds_rules))
 125
 126         ; dfun_uses <- readIORef dfun_uses_var          -- What dfuns are used
 127         ; th_used   <- readIORef th_var                 -- Whether TH is used
 128         ; let used_names = allUses dus `unionNameSets` dfun_uses
 129               pkgs | th_used   = insertList thPackageId (imp_dep_pkgs imports)
 130                    | otherwise = imp_dep_pkgs imports
 131
 132               dep_mods = eltsUFM (delFromUFM (imp_dep_mods imports) (moduleName mod))
 133                 -- M.hi-boot can be in the imp_dep_mods, but we must remove
 134                 -- it before recording the modules on which this one depends!
 135                 -- (We want to retain M.hi-boot in imp_dep_mods so that
 136                 --  loadHiBootInterface can see if M's direct imports depend
 137                 --  on M.hi-boot, and hence that we should do the hi-boot consistency
 138                 --  check.)
 139
 140               dir_imp_mods = imp_mods imports
 141
 142         ; usages <- mkUsageInfo hsc_env dir_imp_mods dep_mods used_names
 143
 144         ; let
 145                 -- Modules don't compare lexicographically usually,
 146                 -- but we want them to do so here.
 147              le_mod :: Module -> Module -> Bool
 148              le_mod m1 m2 = moduleNameFS (moduleName m1)
 149                                 <= moduleNameFS (moduleName m2)
 150              le_dep_mod :: (ModuleName, IsBootInterface) -> (ModuleName, IsBootInterface) -> Bool
 151              le_dep_mod (m1,_) (m2,_) = moduleNameFS m1 <= moduleNameFS m2
 152
 153              deps = Deps { dep_mods   = sortLe le_dep_mod dep_mods,
 154                            dep_pkgs   = sortLe (<=)   pkgs,
 155                            dep_orphs  = sortLe le_mod (imp_orphs  imports),
 156                            dep_finsts = sortLe le_mod (imp_finsts imports) }
 157                 -- sort to get into canonical order
 158
 159              mod_guts = ModGuts {
 160                 mg_module    = mod,
 161                 mg_boot      = isHsBoot hsc_src,
 162                 mg_exports   = exports,
 163                 mg_deps      = deps,
 164                 mg_usages    = usages,
 165                 mg_dir_imps  = [m | (m,_,_) <- moduleEnvElts dir_imp_mods],
 166                 mg_rdr_env   = rdr_env,
 167                 mg_fix_env   = fix_env,
 168                 mg_deprecs   = deprecs,
 169                 mg_types     = type_env,
 170                 mg_insts     = insts,
 171                 mg_fam_insts = fam_insts,
 172                 mg_rules     = ds_rules,
 173                 mg_binds     = ds_binds,
 174                 mg_foreign   = ds_fords,
 175                 mg_hpc_info  = ds_hpc_info,
 176                 mg_dbg_sites = dbgSites }
 177         ; return (Just mod_guts)
 178         }}}
 179
 180   where
 181     dflags    = hsc_dflags hsc_env
 182     ghci_mode = ghcMode (hsc_dflags hsc_env)
 183
 184 mkAutoScc :: Module -> NameSet -> AutoScc
 185 mkAutoScc mod exports
 186   | not opt_SccProfilingOn      -- No profiling
 187   = NoSccs
 188   | opt_AutoSccsOnAllToplevs    -- Add auto-scc on all top-level things
 189   = AddSccs mod (\id -> True)
 190   | opt_AutoSccsOnExportedToplevs       -- Only on exported things
 191   = AddSccs mod (\id -> idName id `elemNameSet` exports)
 192   | otherwise
 193   = NoSccs
 194
 195
 196 deSugarExpr :: HscEnv
 197             -> Module -> GlobalRdrEnv -> TypeEnv
 198             -> LHsExpr Id
 199             -> IO (Maybe CoreExpr)
 200 -- Prints its own errors; returns Nothing if error occurred
 201
 202 deSugarExpr hsc_env this_mod rdr_env type_env tc_expr
 203   = do  { let dflags = hsc_dflags hsc_env
 204         ; showPass dflags "Desugar"
 205
 206         -- Do desugaring
 207         ; mb_core_expr <- initDs hsc_env this_mod rdr_env type_env $
 208                           dsLExpr tc_expr
 209
 210         ; case mb_core_expr of {
 211             Nothing   -> return Nothing ;
 212             Just expr -> do {
 213
 214                 -- Dump output
 215           dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
 216
 217         ; return (Just expr) } } }
 218
 219 --              addExportFlags
 220 -- Set the no-discard flag if either
 221 --      a) the Id is exported
 222 --      b) it's mentioned in the RHS of an orphan rule
 223 --      c) it's in the keep-alive set
 224 --
 225 -- It means that the binding won't be discarded EVEN if the binding
 226 -- ends up being trivial (v = w) -- the simplifier would usually just
 227 -- substitute w for v throughout, but we don't apply the substitution to
 228 -- the rules (maybe we should?), so this substitution would make the rule
 229 -- bogus.
 230
 231 -- You might wonder why exported Ids aren't already marked as such;
 232 -- it's just because the type checker is rather busy already and
 233 -- I didn't want to pass in yet another mapping.
 234
 235 addExportFlags ghci_mode exports keep_alive prs rules
 236   = [(add_export bndr, rhs) | (bndr,rhs) <- prs]
 237   where
 238     add_export bndr
 239         | dont_discard bndr = setIdExported bndr
 240         | otherwise         = bndr
 241
 242     orph_rhs_fvs = unionVarSets [ ruleRhsFreeVars rule
 243                                 | rule <- rules,
 244                                   not (isLocalRule rule) ]
 245         -- A non-local rule keeps alive the free vars of its right-hand side.
 246         -- (A "non-local" is one whose head function is not locally defined.)
 247         -- Local rules are (later, after gentle simplification)
 248         -- attached to the Id, and that keeps the rhs free vars alive.
 249
 250     dont_discard bndr = is_exported name
 251                      || name `elemNameSet` keep_alive
 252                      || bndr `elemVarSet` orph_rhs_fvs
 253                      where
 254                         name = idName bndr
 255
 256         -- In interactive mode, we don't want to discard any top-level
 257         -- entities at all (eg. do not inline them away during
 258         -- simplification), and retain them all in the TypeEnv so they are
 259         -- available from the command line.
 260         --
 261         -- isExternalName separates the user-defined top-level names from those
 262         -- introduced by the type checker.
 263     is_exported :: Name -> Bool
 264     is_exported | ghci_mode == Interactive = isExternalName
 265                 | otherwise                = (`elemNameSet` exports)
 266
 267 ppr_ds_rules [] = empty
 268 ppr_ds_rules rules
 269   = text "" $$ text "-------------- DESUGARED RULES -----------------" $$
 270     pprRules rules
 271 \end{code}
 272
 273
 274
 275 %************************************************************************
 276 %*                                                                      *
 277 %*              Desugaring transformation rules
 278 %*                                                                      *
 279 %************************************************************************
 280
 281 \begin{code}
 282 dsRule :: Module -> IdSet -> LRuleDecl Id -> DsM (Maybe CoreRule)
 283 dsRule mod in_scope (L loc (HsRule name act vars lhs tv_lhs rhs fv_rhs))
 284   = putSrcSpanDs loc $
 285     do  { let bndrs     = [var | RuleBndr (L _ var) <- vars]
 286         ; lhs'  <- dsLExpr lhs
 287         ; rhs'  <- dsLExpr rhs
 288
 289         ; case decomposeRuleLhs bndrs lhs' of {
 290                 Nothing -> do { warnDs msg; return Nothing } ;
 291                 Just (bndrs', fn_id, args) -> do
 292
 293         -- Substitute the dict bindings eagerly,
 294         -- and take the body apart into a (f args) form
 295         { let local_rule = nameIsLocalOrFrom mod fn_name
 296                 -- NB we can't use isLocalId in the orphan test,
 297                 -- because isLocalId isn't true of class methods
 298               fn_name   = idName fn_id
 299               lhs_names = fn_name : nameSetToList (exprsFreeNames args)
 300                 -- No need to delete bndrs, because
 301                 -- exprsFreeNames finds only External names
 302
 303                 -- A rule is an orphan only if none of the variables
 304                 -- mentioned on its left-hand side are locally defined
 305               orph = case filter (nameIsLocalOrFrom mod) lhs_names of
 306                         (n:ns) -> Just (nameOccName n)
 307                         []     -> Nothing
 308
 309               rule = Rule { ru_name = name, ru_fn = fn_name, ru_act = act,
 310                             ru_bndrs = bndrs', ru_args = args, ru_rhs = rhs',
 311                             ru_rough = roughTopNames args,
 312                             ru_local = local_rule, ru_orph = orph }
 313         ; return (Just rule)
 314         } } }
 315   where
 316     msg = hang (ptext SLIT("RULE left-hand side too complicated to desugar; ignored"))
 317              2 (ppr lhs)
 318 \end{code}