unSaturatedOk, needSaturated, boringCxtOk, boringCxtNotOk,
-- ** Predicates and deconstruction on 'Unfolding'
- unfoldingTemplate, setUnfoldingTemplate,
+ unfoldingTemplate, setUnfoldingTemplate, expandUnfolding_maybe,
maybeUnfoldingTemplate, otherCons, unfoldingArity,
isValueUnfolding, isEvaldUnfolding, isCheapUnfolding,
isExpandableUnfolding, isConLikeUnfolding, isCompulsoryUnfolding,
isExpandableUnfolding (CoreUnfolding { uf_expandable = is_expable }) = is_expable
isExpandableUnfolding _ = False
+expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr
+-- Expand an expandable unfolding; this is used in rule matching
+-- See Note [Expanding variables] in Rules.lhs
+-- The key point here is that CONLIKE things can be expanded
+expandUnfolding_maybe (CoreUnfolding { uf_expandable = True, uf_tmpl = rhs }) = Just rhs
+expandUnfolding_maybe _ = Nothing
+
isInlineRule :: Unfolding -> Bool
isInlineRule (CoreUnfolding { uf_src = src }) = isInlineRuleSource src
isInlineRule _ = False
-- Look through unfoldings, but only cheap ones, because
-- we are effectively duplicating the unfolding
- | CoreUnfolding { uf_expandable = expand_me, uf_tmpl = rhs } <- unfolding
- , expand_me = -- pprTrace "expanding" (ppr fun $$ ppr rhs) $
- analyse rhs args
+ | Just rhs <- expandUnfolding_maybe unfolding
+ = -- pprTrace "expanding" (ppr fun $$ ppr rhs) $
+ analyse rhs args
where
is_saturated = count isValArg args == idArity fun
- unfolding = id_unf fun -- Does not look through loop breakers
- -- ToDo: we *may* look through variables that are NOINLINE
- -- in this phase, and that is really not right
+ unfolding = id_unf fun
analyse _ _ = Nothing
hashExpr,
-- * Equality
- cheapEqExpr, eqExpr,
+ cheapEqExpr, eqExpr, eqExprX,
-- * Manipulating data constructors and types
applyTypeToArgs, applyTypeToArg,
eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool
-- Compares for equality, modulo alpha
eqExpr in_scope e1 e2
- = go (mkRnEnv2 in_scope) e1 e2
+ = eqExprX id_unf (mkRnEnv2 in_scope) e1 e2
where
- go _ (Lit lit1) (Lit lit2) = lit1 == lit2
- go env (Type t1) (Type t2) = coreEqType2 env t1 t2
- go env (Var v1) (Var v2) = rnOccL env v1 == rnOccR env v2
- go env (Cast e1 t1) (Cast e2 t2) = go env e1 e2 && coreEqCoercion2 env t1 t2
- go env (App f1 a1) (App f2 a2) = go env f1 f2 && go env a1 a2
+ id_unf _ = noUnfolding -- Don't expand
+\end{code}
+
+\begin{code}
+eqExprX :: IdUnfoldingFun -> RnEnv2 -> CoreExpr -> CoreExpr -> Bool
+-- ^ Compares expressions for equality, modulo alpha.
+-- Does /not/ look through newtypes or predicate types
+-- Used in rule matching, and also CSE
+
+eqExprX id_unfolding_fun env e1 e2
+ = go env e1 e2
+ where
+ go env (Var v1) (Var v2)
+ | rnOccL env v1 == rnOccR env v2
+ = True
+
+ -- The next two rules expand non-local variables
+ -- C.f. Note [Expanding variables] in Rules.lhs
+ -- and Note [Do not expand locally-bound variables] in Rules.lhs
+ go env (Var v1) e2
+ | not (locallyBoundL env v1)
+ , Just e1' <- expandUnfolding_maybe (id_unfolding_fun (lookupRnInScope env v1))
+ = go (nukeRnEnvL env) e1' e2
+
+ go env e1 (Var v2)
+ | not (locallyBoundR env v2)
+ , Just e2' <- expandUnfolding_maybe (id_unfolding_fun (lookupRnInScope env v2))
+ = go (nukeRnEnvR env) e1 e2'
+
+ go _ (Lit lit1) (Lit lit2) = lit1 == lit2
+ go env (Type t1) (Type t2) = tcEqTypeX env t1 t2
+ go env (Cast e1 co1) (Cast e2 co2) = tcEqTypeX env co1 co2 && go env e1 e2
+ go env (App f1 a1) (App f2 a2) = go env f1 f2 && go env a1 a2
+ go env (Note n1 e1) (Note n2 e2) = go_note n1 n2 && go env e1 e2
go env (Lam b1 e1) (Lam b2 e2)
- = coreEqType2 env (varType b1) (varType b2) -- Will return False for Id/TyVar combination
+ = tcEqTypeX env (varType b1) (varType b2) -- False for Id/TyVar combination
&& go (rnBndr2 env b1 b2) e1 e2
+ go env (Let (NonRec v1 r1) e1) (Let (NonRec v2 r2) e2)
+ = go env r1 r2 -- No need to check binder types, since RHSs match
+ && go (rnBndr2 env v1 v2) e1 e2
+
+ go env (Let (Rec ps1) e1) (Let (Rec ps2) e2)
+ = all2 (go env') rs1 rs2 && go env' e1 e2
+ where
+ (bs1,rs1) = unzip ps1
+ (bs2,rs2) = unzip ps2
+ env' = rnBndrs2 env bs1 bs2
+
go env (Case e1 b1 _ a1) (Case e2 b2 _ a2)
= go env e1 e2
- && coreEqType2 env (idType b1) (idType b2)
+ && tcEqTypeX env (idType b1) (idType b2)
&& all2 (go_alt (rnBndr2 env b1 b2)) a1 a2
-
- go env (Let (NonRec b1 r1) e1) (Let (NonRec b2 r2) e2)
- = go env r1 r2 -- No need to check binder types, since RHSs match
- && go (rnBndr2 env b1 b2) e1 e2
-
- go env (Let (Rec p1) e1) (Let (Rec p2) e2)
- | equalLength p1 p2
- = all2 (go env') rs1 rs2 && go env' e1 e2
- where
- (bs1,rs1) = unzip p1
- (bs2,rs2) = unzip p2
- env' = rnBndrs2 env bs1 bs2
-
- go env (Note n1 e1) (Note n2 e2) = go_note n1 n2 && go env e1 e2
go _ _ _ = False
= c1 == c2 && go (rnBndrs2 env bs1 bs2) e1 e2
-----------
- go_note (SCC cc1) (SCC cc2) = cc1==cc2
- go_note (CoreNote s1) (CoreNote s2) = s1==s2
- go_note _ _ = False
+ go_note (SCC cc1) (SCC cc2) = cc1 == cc2
+ go_note (CoreNote s1) (CoreNote s2) = s1 == s2
+ go_note _ _ = False
\end{code}
-
+
+Auxiliary functions
+
+\begin{code}
+locallyBoundL, locallyBoundR :: RnEnv2 -> Var -> Bool
+locallyBoundL rn_env v = inRnEnvL rn_env v
+locallyBoundR rn_env v = inRnEnvR rn_env v
+\end{code}
+
%************************************************************************
%* *
import CoreSyn -- All of it
import OccurAnal ( occurAnalyseExpr )
import CoreFVs ( exprFreeVars, exprsFreeVars, bindFreeVars, rulesFreeVars )
-import CoreUtils ( exprType )
+import CoreUtils ( exprType, eqExprX )
import PprCore ( pprRules )
-import Type ( Type, TvSubstEnv, tcEqTypeX )
+import Type ( Type, TvSubstEnv )
import TcType ( tcSplitTyConApp_maybe )
import CoreTidy ( tidyRules )
import Id
-- See Note [Notes in RULE matching]
match id_unfolding_fun menv subst e1 (Var v2) -- Note [Expanding variables]
- | not (locallyBoundR rn_env v2) -- Note [Do not expand locally-bound variables]
- , Just e2' <- expandUnfolding (id_unfolding_fun v2')
+ | not (inRnEnvR rn_env v2) -- Note [Do not expand locally-bound variables]
+ , Just e2' <- expandUnfolding_maybe (id_unfolding_fun v2')
= match id_unfolding_fun (menv { me_env = nukeRnEnvR rn_env }) subst e1 e2'
where
v2' = lookupRnInScope rn_env v2
-- Notice that we look up v2 in the in-scope set
-- See Note [Lookup in-scope]
-- No need to apply any renaming first (hence no rnOccR)
- -- becuase of the not-locallyBoundR
+ -- because of the not-inRnEnvR
match idu menv (tv_subst, id_subst, binds) e1 (Let bind e2)
| all freshly_bound bndrs -- See Note [Matching lets]
- , not (any (locallyBoundR rn_env) bind_fvs)
+ , not (any (inRnEnvR rn_env) bind_fvs)
= match idu (menv { me_env = rn_env' })
(tv_subst, id_subst, binds `snocOL` bind')
e1 e2'
-- c.f. match_ty below
; return (tv_subst', extendVarEnv id_subst v1' e2, binds) }
- Just e1' | eqExpr idu (nukeRnEnvL rn_env) e1' e2
+ Just e1' | eqExprX idu (nukeRnEnvL rn_env) e1' e2
-> Just subst
| otherwise
That is why the 'lookupRnInScope' call in the (Var v2) case of 'match'
is so important.
-\begin{code}
-eqExpr :: IdUnfoldingFun -> RnEnv2 -> CoreExpr -> CoreExpr -> Bool
--- ^ A kind of shallow equality used in rule matching, so does
--- /not/ look through newtypes or predicate types
-
-eqExpr _ env (Var v1) (Var v2)
- | rnOccL env v1 == rnOccR env v2
- = True
-
--- The next two rules expand non-local variables
--- C.f. Note [Expanding variables]
--- and Note [Do not expand locally-bound variables]
-eqExpr id_unfolding_fun env (Var v1) e2
- | not (locallyBoundL env v1)
- , Just e1' <- expandUnfolding (id_unfolding_fun (lookupRnInScope env v1))
- = eqExpr id_unfolding_fun (nukeRnEnvL env) e1' e2
-
-eqExpr id_unfolding_fun env e1 (Var v2)
- | not (locallyBoundR env v2)
- , Just e2' <- expandUnfolding (id_unfolding_fun (lookupRnInScope env v2))
- = eqExpr id_unfolding_fun (nukeRnEnvR env) e1 e2'
-
-eqExpr _ _ (Lit lit1) (Lit lit2) = lit1 == lit2
-eqExpr idu env (App f1 a1) (App f2 a2) = eqExpr idu env f1 f2 && eqExpr idu env a1 a2
-eqExpr idu env (Lam v1 e1) (Lam v2 e2) = eqExpr idu (rnBndr2 env v1 v2) e1 e2
-eqExpr idu env (Note n1 e1) (Note n2 e2) = eq_note env n1 n2 && eqExpr idu env e1 e2
-eqExpr idu env (Cast e1 co1) (Cast e2 co2) = tcEqTypeX env co1 co2 && eqExpr idu env e1 e2
-eqExpr _ env (Type t1) (Type t2) = tcEqTypeX env t1 t2
-
-eqExpr idu env (Let (NonRec v1 r1) e1)
- (Let (NonRec v2 r2) e2) = eqExpr idu env r1 r2
- && eqExpr idu (rnBndr2 env v1 v2) e1 e2
-eqExpr idu env (Let (Rec ps1) e1)
- (Let (Rec ps2) e2) = equalLength ps1 ps2
- && and (zipWith eq_rhs ps1 ps2)
- && eqExpr idu env' e1 e2
- where
- env' = foldl2 rn_bndr2 env ps2 ps2
- rn_bndr2 env (b1,_) (b2,_) = rnBndr2 env b1 b2
- eq_rhs (_,r1) (_,r2) = eqExpr idu env' r1 r2
-eqExpr idu env (Case e1 v1 t1 a1)
- (Case e2 v2 t2 a2) = eqExpr idu env e1 e2
- && tcEqTypeX env t1 t2
- && equalLength a1 a2
- && and (zipWith eq_alt a1 a2)
- where
- env' = rnBndr2 env v1 v2
- eq_alt (c1,vs1,r1) (c2,vs2,r2)
- = c1==c2 && eqExpr idu (rnBndrs2 env' vs1 vs2) r1 r2
-eqExpr _ _ _ _ = False
-
-eq_note :: RnEnv2 -> Note -> Note -> Bool
-eq_note _ (SCC cc1) (SCC cc2) = cc1 == cc2
-eq_note _ (CoreNote s1) (CoreNote s2) = s1 == s2
-eq_note _ _ _ = False
-\end{code}
-
-Auxiliary functions
-
-\begin{code}
-locallyBoundL, locallyBoundR :: RnEnv2 -> Var -> Bool
-locallyBoundL rn_env v = inRnEnvL rn_env v
-locallyBoundR rn_env v = inRnEnvR rn_env v
-
-
-expandUnfolding :: Unfolding -> Maybe CoreExpr
-expandUnfolding unfolding
- | isExpandableUnfolding unfolding = Just (unfoldingTemplate unfolding)
- | otherwise = Nothing
-\end{code}
-
%************************************************************************
%* *
Rule-check the program
projects / ghc-hetmet.git / commitdiff