compiler/coreSyn/CoreTidy.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1996-1998
   3 %
   4
   5 \begin{code}
   6 module CoreTidy (
   7         tidyExpr, tidyVarOcc, tidyRule, tidyRules
   8     ) where
   9
  10 #include "HsVersions.h"
  11
  12 import CoreSyn
  13 import CoreUtils        ( exprArity )
  14 import DataCon          ( DataCon )
  15 import Id               ( Id, mkUserLocal, idInfo, setIdInfo, idUnique,
  16                           idType, setIdType )
  17 import IdInfo           ( setArityInfo, vanillaIdInfo,
  18                           newStrictnessInfo, setAllStrictnessInfo,
  19                           newDemandInfo, setNewDemandInfo )
  20 import Type             ( Type, tidyType, tidyTyVarBndr, substTy, mkOpenTvSubst )
  21 import Var              ( Var, TyVar, varName )
  22 import VarEnv
  23 import UniqFM           ( lookupUFM )
  24 import Name             ( Name, getOccName )
  25 import OccName          ( tidyOccName )
  26 import SrcLoc           ( noSrcLoc )
  27 import Maybes           ( orElse )
  28 import Outputable
  29 import Util             ( mapAccumL )
  30 \end{code}
  31
  32
  33 This module contains "tidying" code for *nested* expressions, bindings, rules.
  34 The code for *top-level* bindings is in TidyPgm.
  35
  36 %************************************************************************
  37 %*                                                                      *
  38 \subsection{Tidying expressions, rules}
  39 %*                                                                      *
  40 %************************************************************************
  41
  42 \begin{code}
  43 tidyBind :: TidyEnv
  44          -> CoreBind
  45          ->  (TidyEnv, CoreBind)
  46
  47 tidyBind env (NonRec bndr rhs)
  48   = tidyLetBndr env (bndr,rhs) =: \ (env', bndr') ->
  49     (env', NonRec bndr' (tidyExpr env' rhs))
  50
  51 tidyBind env (Rec prs)
  52   = mapAccumL tidyLetBndr  env prs      =: \ (env', bndrs') ->
  53     map (tidyExpr env') (map snd prs)   =: \ rhss' ->
  54     (env', Rec (zip bndrs' rhss'))
  55
  56
  57 ------------  Expressions  --------------
  58 tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr
  59 tidyExpr env (Var v)     =  Var (tidyVarOcc env v)
  60 tidyExpr env (Type ty)   =  Type (tidyType env ty)
  61 tidyExpr env (Lit lit)   =  Lit lit
  62 tidyExpr env (App f a)   =  App (tidyExpr env f) (tidyExpr env a)
  63 tidyExpr env (Note n e)  =  Note (tidyNote env n) (tidyExpr env e)
  64 tidyExpr env (Cast e co) =  Cast (tidyExpr env e) (tidyType env co)
  65
  66 tidyExpr env (Let b e)
  67   = tidyBind env b      =: \ (env', b') ->
  68     Let b' (tidyExpr env' e)
  69
  70 tidyExpr env (Case e b ty alts)
  71   = tidyBndr env b      =: \ (env', b) ->
  72     Case (tidyExpr env e) b (tidyType env ty)
  73          (map (tidyAlt b env') alts)
  74
  75 tidyExpr env (Lam b e)
  76   = tidyBndr env b      =: \ (env', b) ->
  77     Lam b (tidyExpr env' e)
  78
  79 ------------  Case alternatives  --------------
  80 tidyAlt case_bndr env (con, vs, rhs)
  81   = tidyBndrs env vs    =: \ (env', vs) ->
  82     (con, vs, tidyExpr env' rhs)
  83
  84 ------------  Notes  --------------
  85 tidyNote env note            = note
  86
  87 ------------  Rules  --------------
  88 tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]
  89 tidyRules env [] = []
  90 tidyRules env (rule : rules)
  91   = tidyRule env rule           =: \ rule ->
  92     tidyRules env rules         =: \ rules ->
  93     (rule : rules)
  94
  95 tidyRule :: TidyEnv -> CoreRule -> CoreRule
  96 tidyRule env rule@(BuiltinRule {}) = rule
  97 tidyRule env rule@(Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs,
  98                           ru_fn = fn, ru_rough = mb_ns })
  99   = tidyBndrs env bndrs         =: \ (env', bndrs) ->
 100     map (tidyExpr env') args    =: \ args ->
 101     rule { ru_bndrs = bndrs, ru_args = args,
 102            ru_rhs   = tidyExpr env' rhs,
 103            ru_fn    = tidyNameOcc env fn,
 104            ru_rough = map (fmap (tidyNameOcc env')) mb_ns }
 105 \end{code}
 106
 107
 108 %************************************************************************
 109 %*                                                                      *
 110 \subsection{Tidying non-top-level binders}
 111 %*                                                                      *
 112 %************************************************************************
 113
 114 \begin{code}
 115 tidyNameOcc :: TidyEnv -> Name -> Name
 116 -- In rules and instances, we have Names, and we must tidy them too
 117 -- Fortunately, we can lookup in the VarEnv with a name
 118 tidyNameOcc (_, var_env) n = case lookupUFM var_env n of
 119                                 Nothing -> n
 120                                 Just v  -> varName v
 121
 122 tidyVarOcc :: TidyEnv -> Var -> Var
 123 tidyVarOcc (_, var_env) v = lookupVarEnv var_env v `orElse` v
 124
 125 -- tidyBndr is used for lambda and case binders
 126 tidyBndr :: TidyEnv -> Var -> (TidyEnv, Var)
 127 tidyBndr env var
 128   | isTyVar var = tidyTyVarBndr env var
 129   | otherwise   = tidyIdBndr env var
 130
 131 tidyBndrs :: TidyEnv -> [Var] -> (TidyEnv, [Var])
 132 tidyBndrs env vars = mapAccumL tidyBndr env vars
 133
 134 tidyLetBndr :: TidyEnv -> (Id, CoreExpr) -> (TidyEnv, Var)
 135 -- Used for local (non-top-level) let(rec)s
 136 tidyLetBndr env (id,rhs)
 137   = ((tidy_env,new_var_env), final_id)
 138   where
 139     ((tidy_env,var_env), new_id) = tidyIdBndr env id
 140
 141         -- We need to keep around any interesting strictness and
 142         -- demand info because later on we may need to use it when
 143         -- converting to A-normal form.
 144         -- eg.
 145         --      f (g x),  where f is strict in its argument, will be converted
 146         --      into  case (g x) of z -> f z  by CorePrep, but only if f still
 147         --      has its strictness info.
 148         --
 149         -- Similarly for the demand info - on a let binder, this tells
 150         -- CorePrep to turn the let into a case.
 151         --
 152         -- Similarly arity info for eta expansion in CorePrep
 153         --
 154     final_id = new_id `setIdInfo` new_info
 155     idinfo   = idInfo id
 156     new_info = vanillaIdInfo
 157                 `setArityInfo`          exprArity rhs
 158                 `setAllStrictnessInfo`  newStrictnessInfo idinfo
 159                 `setNewDemandInfo`      newDemandInfo idinfo
 160
 161     -- Override the env we get back from tidyId with the new IdInfo
 162     -- so it gets propagated to the usage sites.
 163     new_var_env = extendVarEnv var_env id final_id
 164
 165 -- Non-top-level variables
 166 tidyIdBndr :: TidyEnv -> Id -> (TidyEnv, Id)
 167 tidyIdBndr env@(tidy_env, var_env) id
 168   = -- do this pattern match strictly, otherwise we end up holding on to
 169     -- stuff in the OccName.
 170     case tidyOccName tidy_env (getOccName id) of { (tidy_env', occ') ->
 171     let
 172         -- Give the Id a fresh print-name, *and* rename its type
 173         -- The SrcLoc isn't important now,
 174         -- though we could extract it from the Id
 175         --
 176         -- All nested Ids now have the same IdInfo, namely vanillaIdInfo,
 177         -- which should save some space.
 178         -- But note that tidyLetBndr puts some of it back.
 179         ty'               = tidyType env (idType id)
 180         id'               = mkUserLocal occ' (idUnique id) ty' noSrcLoc
 181                                 `setIdInfo` vanillaIdInfo
 182         var_env'          = extendVarEnv var_env id id'
 183     in
 184      ((tidy_env', var_env'), id')
 185    }
 186 \end{code}
 187
 188 \begin{code}
 189 m =: k = m `seq` k m
 190 \end{code}