{-# OPTIONS -w #-} {-# LANGUAGE PatternGuards #-} -- The above warning supression flag is a temporary kludge. -- While working on this module you are encouraged to remove it and fix -- any warnings in the module. See -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings -- for details -- | Functions for collecting together and applying rewrite rules to a module. -- The 'CoreRule' datatype itself is declared elsewhere. module Rules ( -- * RuleBase RuleBase, -- ** Constructing emptyRuleBase, mkRuleBase, extendRuleBaseList, unionRuleBase, pprRuleBase, -- ** Checking rule applications ruleCheckProgram, -- ** Manipulating 'SpecInfo' rules mkSpecInfo, extendSpecInfo, addSpecInfo, addIdSpecialisations, -- * Misc. CoreRule helpers rulesOfBinds, getRules, pprRulesForUser, lookupRule, mkLocalRule, roughTopNames ) where -- #include "HsVersions.h" import CoreSyn -- All of it import OccurAnal ( occurAnalyseExpr ) import CoreFVs ( exprFreeVars, exprsFreeVars, bindFreeVars, rulesFreeVars ) import CoreUtils ( tcEqExprX, exprType ) import PprCore ( pprRules ) import Type ( Type, TvSubstEnv ) import Coercion ( coercionKind ) import TcType ( tcSplitTyConApp_maybe ) import CoreTidy ( tidyRules ) import Id import IdInfo ( SpecInfo( SpecInfo ) ) import Var ( Var ) import VarEnv import VarSet import Name ( Name, NamedThing(..) ) import NameEnv import Unify ( ruleMatchTyX, MatchEnv(..) ) import BasicTypes ( Activation ) import StaticFlags ( opt_PprStyle_Debug ) import Outputable import FastString import Maybes import OrdList import Bag import Util import Data.List mkLocalRule :: RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule -- ^ Used to make 'CoreRule' for an 'Id' defined in the module being -- compiled. See also 'CoreSyn.CoreRule' mkLocalRule name act fn bndrs args rhs = Rule { ru_name = name, ru_fn = fn, ru_act = act, ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs, ru_rough = roughTopNames args, ru_local = True } -------------- roughTopNames :: [CoreExpr] -> [Maybe Name] -- ^ Find the \"top\" free names of several expressions. -- Such names are either: -- -- 1. The function finally being applied to in an application chain -- (if that name is a GlobalId: see "Var#globalvslocal"), or -- -- 2. The 'TyCon' if the expression is a 'Type' -- -- This is used for the fast-match-check for rules; -- if the top names don't match, the rest can't roughTopNames args = map roughTopName args roughTopName :: CoreExpr -> Maybe Name roughTopName (Type ty) = case tcSplitTyConApp_maybe ty of Just (tc,_) -> Just (getName tc) Nothing -> Nothing roughTopName (App f a) = roughTopName f roughTopName (Var f) | isGlobalId f = Just (idName f) | otherwise = Nothing roughTopName other = Nothing ruleCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool -- ^ @ruleCantMatch tpl actual@ returns True only if @actual@ -- definitely can't match @tpl@ by instantiating @tpl@. -- It's only a one-way match; unlike instance matching we -- don't consider unification. -- -- Notice that [_$_] -- @ruleCantMatch [Nothing] [Just n2] = False@ -- Reason: a template variable can be instantiated by a constant -- Also: -- @ruleCantMatch [Just n1] [Nothing] = False@ -- Reason: a local variable @v@ in the actuals might [_$_] ruleCantMatch (Just n1 : ts) (Just n2 : as) = n1 /= n2 || ruleCantMatch ts as ruleCantMatch (t : ts) (a : as) = ruleCantMatch ts as ruleCantMatch ts as = False pprRulesForUser :: [CoreRule] -> SDoc -- (a) tidy the rules -- (b) sort them into order based on the rule name -- (c) suppress uniques (unless -dppr-debug is on) -- This combination makes the output stable so we can use in testing -- It's here rather than in PprCore because it calls tidyRules pprRulesForUser rules = withPprStyle defaultUserStyle $ pprRules $ sortLe le_rule $ tidyRules emptyTidyEnv rules where le_rule r1 r2 = ru_name r1 <= ru_name r2 -- | Make a 'SpecInfo' containing a number of 'CoreRule's, suitable -- for putting into an 'IdInfo' mkSpecInfo :: [CoreRule] -> SpecInfo mkSpecInfo rules = SpecInfo rules (rulesFreeVars rules) extendSpecInfo :: SpecInfo -> [CoreRule] -> SpecInfo extendSpecInfo (SpecInfo rs1 fvs1) rs2 = SpecInfo (rs2 ++ rs1) (rulesFreeVars rs2 `unionVarSet` fvs1) addSpecInfo :: SpecInfo -> SpecInfo -> SpecInfo addSpecInfo (SpecInfo rs1 fvs1) (SpecInfo rs2 fvs2) = SpecInfo (rs1 ++ rs2) (fvs1 `unionVarSet` fvs2) addIdSpecialisations :: Id -> [CoreRule] -> Id addIdSpecialisations id [] = id addIdSpecialisations id rules = setIdSpecialisation id $ extendSpecInfo (idSpecialisation id) rules -- | Gather all the rules for locally bound identifiers from the supplied bindings rulesOfBinds :: [CoreBind] -> [CoreRule] rulesOfBinds binds = concatMap (concatMap idCoreRules . bindersOf) binds getRules :: RuleBase -> Id -> [CoreRule] -- The rules for an Id come from two places: -- (a) the ones it is born with (idCoreRules fn) -- (b) rules added in subsequent modules (extra_rules) -- PrimOps, for example, are born with a bunch of rules under (a) getRules rule_base fn | isLocalId fn = idCoreRules fn | otherwise = WARN( not (isPrimOpId fn) && notNull (idCoreRules fn), ppr fn <+> ppr (idCoreRules fn) ) idCoreRules fn ++ (lookupNameEnv rule_base (idName fn) `orElse` []) -- Only PrimOpIds have rules inside themselves, and perhaps more besides -- | Gathers a collection of 'CoreRule's. Maps (the name of) an 'Id' to its rules type RuleBase = NameEnv [CoreRule] -- The rules are are unordered; -- we sort out any overlaps on lookup emptyRuleBase = emptyNameEnv mkRuleBase :: [CoreRule] -> RuleBase mkRuleBase rules = extendRuleBaseList emptyRuleBase rules extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase extendRuleBaseList rule_base new_guys = foldl extendRuleBase rule_base new_guys unionRuleBase :: RuleBase -> RuleBase -> RuleBase unionRuleBase rb1 rb2 = plusNameEnv_C (++) rb1 rb2 extendRuleBase :: RuleBase -> CoreRule -> RuleBase extendRuleBase rule_base rule = extendNameEnv_Acc (:) singleton rule_base (ruleIdName rule) rule pprRuleBase :: RuleBase -> SDoc pprRuleBase rules = vcat [ pprRules (tidyRules emptyTidyEnv rs) | rs <- nameEnvElts rules ] -- | The main rule matching function. Attempts to apply all (active) -- supplied rules to this instance of an application in a given -- context, returning the rule applied and the resulting expression if -- successful. lookupRule :: (Activation -> Bool) -> InScopeSet -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr) -- See Note [Extra args in rule matching] -- See comments on matchRule lookupRule is_active in_scope fn args rules = -- pprTrace "matchRules" (ppr fn <+> ppr rules) $ case go [] rules of [] -> Nothing (m:ms) -> Just (findBest (fn,args) m ms) where rough_args = map roughTopName args go :: [(CoreRule,CoreExpr)] -> [CoreRule] -> [(CoreRule,CoreExpr)] go ms [] = ms go ms (r:rs) = case (matchRule is_active in_scope args rough_args r) of Just e -> go ((r,e):ms) rs Nothing -> -- pprTrace "match failed" (ppr r $$ ppr args $$ -- ppr [(arg_id, unfoldingTemplate unf) | Var arg_id <- args, let unf = idUnfolding arg_id, isCheapUnfolding unf] ) go ms rs findBest :: (Id, [CoreExpr]) -> (CoreRule,CoreExpr) -> [(CoreRule,CoreExpr)] -> (CoreRule,CoreExpr) -- All these pairs matched the expression -- Return the pair the the most specific rule -- The (fn,args) is just for overlap reporting findBest target (rule,ans) [] = (rule,ans) findBest target (rule1,ans1) ((rule2,ans2):prs) | rule1 `isMoreSpecific` rule2 = findBest target (rule1,ans1) prs | rule2 `isMoreSpecific` rule1 = findBest target (rule2,ans2) prs | debugIsOn = let pp_rule rule | opt_PprStyle_Debug = ppr rule | otherwise = doubleQuotes (ftext (ru_name rule)) in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)" (vcat [if opt_PprStyle_Debug then ptext (sLit "Expression to match:") <+> ppr fn <+> sep (map ppr args) else empty, ptext (sLit "Rule 1:") <+> pp_rule rule1, ptext (sLit "Rule 2:") <+> pp_rule rule2]) $ findBest target (rule1,ans1) prs | otherwise = findBest target (rule1,ans1) prs where (fn,args) = target isMoreSpecific :: CoreRule -> CoreRule -> Bool isMoreSpecific (BuiltinRule {}) r2 = True isMoreSpecific r1 (BuiltinRule {}) = False isMoreSpecific (Rule { ru_bndrs = bndrs1, ru_args = args1 }) (Rule { ru_bndrs = bndrs2, ru_args = args2 }) = isJust (matchN in_scope bndrs2 args2 args1) where in_scope = mkInScopeSet (mkVarSet bndrs1) -- Actually we should probably include the free vars -- of rule1's args, but I can't be bothered noBlackList :: Activation -> Bool noBlackList act = False -- Nothing is black listed matchRule :: (Activation -> Bool) -> InScopeSet -> [CoreExpr] -> [Maybe Name] -> CoreRule -> Maybe CoreExpr -- If (matchRule rule args) returns Just (name,rhs) -- then (f args) matches the rule, and the corresponding -- rewritten RHS is rhs -- -- The bndrs and rhs is occurrence-analysed -- -- Example -- -- The rule -- forall f g x. map f (map g x) ==> map (f . g) x -- is stored -- CoreRule "map/map" -- [f,g,x] -- tpl_vars -- [f,map g x] -- tpl_args -- map (f.g) x) -- rhs -- -- Then the call: matchRule the_rule [e1,map e2 e3] -- = Just ("map/map", (\f,g,x -> rhs) e1 e2 e3) -- -- Any 'surplus' arguments in the input are simply put on the end -- of the output. matchRule is_active in_scope args rough_args (BuiltinRule { ru_name = name, ru_try = match_fn }) = case match_fn args of Just expr -> Just expr Nothing -> Nothing matchRule is_active in_scope args rough_args (Rule { ru_name = rn, ru_act = act, ru_rough = tpl_tops, ru_bndrs = tpl_vars, ru_args = tpl_args, ru_rhs = rhs }) | not (is_active act) = Nothing | ruleCantMatch tpl_tops rough_args = Nothing | otherwise = case matchN in_scope tpl_vars tpl_args args of Nothing -> Nothing Just (binds, tpl_vals) -> Just (mkLets binds $ rule_fn `mkApps` tpl_vals) where rule_fn = occurAnalyseExpr (mkLams tpl_vars rhs) -- We could do this when putting things into the rulebase, I guess -- For a given match template and context, find bindings to wrap around -- the entire result and what should be substituted for each template variable. -- Fail if there are two few actual arguments from the target to match the template matchN :: InScopeSet -- ^ In-scope variables -> [Var] -- ^ Match template type variables -> [CoreExpr] -- ^ Match template -> [CoreExpr] -- ^ Target; can have more elements than the template -> Maybe ([CoreBind], [CoreExpr]) matchN in_scope tmpl_vars tmpl_es target_es = do { (tv_subst, id_subst, binds) <- go init_menv emptySubstEnv tmpl_es target_es ; return (fromOL binds, map (lookup_tmpl tv_subst id_subst) tmpl_vars') } where (init_rn_env, tmpl_vars') = mapAccumL rnBndrL (mkRnEnv2 in_scope) tmpl_vars -- See Note [Template binders] init_menv = ME { me_tmpls = mkVarSet tmpl_vars', me_env = init_rn_env } go menv subst [] es = Just subst go menv subst ts [] = Nothing -- Fail if too few actual args go menv subst (t:ts) (e:es) = do { subst1 <- match menv subst t e ; go menv subst1 ts es } lookup_tmpl :: TvSubstEnv -> IdSubstEnv -> Var -> CoreExpr lookup_tmpl tv_subst id_subst tmpl_var' | isTyVar tmpl_var' = case lookupVarEnv tv_subst tmpl_var' of Just ty -> Type ty Nothing -> unbound tmpl_var' | otherwise = case lookupVarEnv id_subst tmpl_var' of Just e -> e other -> unbound tmpl_var' unbound var = pprPanic "Template variable unbound in rewrite rule" (ppr var $$ ppr tmpl_vars $$ ppr tmpl_vars' $$ ppr tmpl_es $$ ppr target_es) -- These two definitions are not the same as in Subst, -- but they simple and direct, and purely local to this module -- -- * The domain of the TvSubstEnv and IdSubstEnv are the template -- variables passed into the match. -- -- * The (OrdList CoreBind) in a SubstEnv are the bindings floated out -- from nested matches; see the Let case of match, below -- type SubstEnv = (TvSubstEnv, IdSubstEnv, OrdList CoreBind) type IdSubstEnv = IdEnv CoreExpr emptySubstEnv :: SubstEnv emptySubstEnv = (emptyVarEnv, emptyVarEnv, nilOL) -- At one stage I tried to match even if there are more -- template args than real args. -- I now think this is probably a bad idea. -- Should the template (map f xs) match (map g)? I think not. -- For a start, in general eta expansion wastes work. -- SLPJ July 99 match :: MatchEnv -> SubstEnv -> CoreExpr -- Template -> CoreExpr -- Target -> Maybe SubstEnv -- See the notes with Unify.match, which matches types -- Everything is very similar for terms -- Interesting examples: -- Consider matching -- \x->f against \f->f -- When we meet the lambdas we must remember to rename f to f' in the -- second expresion. The RnEnv2 does that. -- -- Consider matching -- forall a. \b->b against \a->3 -- We must rename the \a. Otherwise when we meet the lambdas we -- might substitute [a/b] in the template, and then erroneously -- succeed in matching what looks like the template variable 'a' against 3. -- The Var case follows closely what happens in Unify.match match menv subst (Var v1) e2 | Just subst <- match_var menv subst v1 e2 = Just subst match menv subst e1 (Note n e2) = match menv subst e1 e2 -- Note [Notes in RULE matching] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- Look through Notes. In particular, we don't want to -- be confused by InlineMe notes. Maybe we should be more -- careful about profiling notes, but for now I'm just -- riding roughshod over them. --- See Note [Notes in call patterns] in SpecConstr -- Here is another important rule: if the term being matched is a -- variable, we expand it so long as its unfolding is a WHNF -- (Its occurrence information is not necessarily up to date, -- so we don't use it.) match menv subst e1 (Var v2) | isCheapUnfolding unfolding = match menv subst e1 (unfoldingTemplate unfolding) where rn_env = me_env menv unfolding = idUnfolding (lookupRnInScope rn_env (rnOccR rn_env v2)) -- Notice that we look up v2 in the in-scope set -- See Note [Lookup in-scope] -- Remember to apply any renaming first (hence rnOccR) -- Note [Matching lets] -- ~~~~~~~~~~~~~~~~~~~~ -- Matching a let-expression. Consider -- RULE forall x. f (g x) = -- and target expression -- f (let { w=R } in g E)) -- Then we'd like the rule to match, to generate -- let { w=R } in (\x. ) E -- In effect, we want to float the let-binding outward, to enable -- the match to happen. This is the WHOLE REASON for accumulating -- bindings in the SubstEnv -- -- We can only do this if -- (a) Widening the scope of w does not capture any variables -- We use a conservative test: w is not already in scope -- If not, we clone the binders, and substitute -- (b) The free variables of R are not bound by the part of the -- target expression outside the let binding; e.g. -- f (\v. let w = v+1 in g E) -- Here we obviously cannot float the let-binding for w. -- -- You may think rule (a) would never apply, because rule matching is -- mostly invoked from the simplifier, when we have just run substExpr -- over the argument, so there will be no shadowing anyway. -- The fly in the ointment is that the forall'd variables of the -- RULE itself are considered in scope. -- -- I though of various cheapo ways to solve this tiresome problem, -- but ended up doing the straightforward thing, which is to -- clone the binders if they are in scope. It's tiresome, and -- potentially inefficient, because of the calls to substExpr, -- but I don't think it'll happen much in pracice. {- Cases to think about (let x=y+1 in \x. (x,x)) --> let x=y+1 in (\x1. (x1,x1)) (\x. let x = y+1 in (x,x)) --> let x1 = y+1 in (\x. (x1,x1) (let x=y+1 in (x,x), let x=y-1 in (x,x)) --> let x=y+1 in let x1=y-1 in ((x,x),(x1,x1)) Watch out! (let x=y+1 in let z=x+1 in (z,z) --> matches (p,p) but watch out that the use of x on z's rhs is OK! I'm removing the cloning because that makes the above case fail, because the inner let looks as if it has locally-bound vars -} match menv subst@(tv_subst, id_subst, binds) e1 (Let bind e2) | all freshly_bound bndrs, not (any locally_bound bind_fvs) = match (menv { me_env = rn_env' }) (tv_subst, id_subst, binds `snocOL` bind') e1 e2' where rn_env = me_env menv bndrs = bindersOf bind bind_fvs = varSetElems (bindFreeVars bind) locally_bound x = inRnEnvR rn_env x freshly_bound x = not (x `rnInScope` rn_env) bind' = bind e2' = e2 rn_env' = extendRnInScopeList rn_env bndrs {- (rn_env', bndrs') = mapAccumL rnBndrR rn_env bndrs s_prs = [(bndr, Var bndr') | (bndr,bndr') <- zip bndrs bndrs', bndr /= bndr'] subst = mkSubst (rnInScopeSet rn_env) emptyVarEnv (mkVarEnv s_prs) (bind', e2') | null s_prs = (bind, e2) | otherwise = (s_bind, substExpr subst e2) s_bind = case bind of NonRec {} -> NonRec (head bndrs') (head rhss) Rec {} -> Rec (bndrs' `zip` map (substExpr subst) rhss) -} match menv subst (Lit lit1) (Lit lit2) | lit1 == lit2 = Just subst match menv subst (App f1 a1) (App f2 a2) = do { subst' <- match menv subst f1 f2 ; match menv subst' a1 a2 } match menv subst (Lam x1 e1) (Lam x2 e2) = match menv' subst e1 e2 where menv' = menv { me_env = rnBndr2 (me_env menv) x1 x2 } -- This rule does eta expansion -- (\x.M) ~ N iff M ~ N x -- It's important that this is *after* the let rule, -- so that (\x.M) ~ (let y = e in \y.N) -- does the let thing, and then gets the lam/lam rule above match menv subst (Lam x1 e1) e2 = match menv' subst e1 (App e2 (varToCoreExpr new_x)) where (rn_env', new_x) = rnBndrL (me_env menv) x1 menv' = menv { me_env = rn_env' } -- Eta expansion the other way -- M ~ (\y.N) iff M y ~ N match menv subst e1 (Lam x2 e2) = match menv' subst (App e1 (varToCoreExpr new_x)) e2 where (rn_env', new_x) = rnBndrR (me_env menv) x2 menv' = menv { me_env = rn_env' } match menv subst (Case e1 x1 ty1 alts1) (Case e2 x2 ty2 alts2) = do { subst1 <- match_ty menv subst ty1 ty2 ; subst2 <- match menv subst1 e1 e2 ; let menv' = menv { me_env = rnBndr2 (me_env menv) x1 x2 } ; match_alts menv' subst2 alts1 alts2 -- Alts are both sorted } match menv subst (Type ty1) (Type ty2) = match_ty menv subst ty1 ty2 match menv subst (Cast e1 co1) (Cast e2 co2) = do { subst1 <- match_ty menv subst co1 co2 ; match menv subst1 e1 e2 } {- REMOVING OLD CODE: I think that the above handling for let is better than the stuff here, which looks pretty suspicious to me. SLPJ Sept 06 -- This is an interesting rule: we simply ignore lets in the -- term being matched against! The unfolding inside it is (by assumption) -- already inside any occurrences of the bound variables, so we'll expand -- them when we encounter them. This gives a chance of matching -- forall x,y. f (g (x,y)) -- against -- f (let v = (a,b) in g v) match menv subst e1 (Let bind e2) = match (menv { me_env = rn_env' }) subst e1 e2 where (rn_env', _bndrs') = mapAccumL rnBndrR (me_env menv) (bindersOf bind) -- It's important to do this renaming, so that the bndrs -- are brought into the local scope. For example: -- Matching -- forall f,x,xs. f (x:xs) -- against -- f (let y = e in (y:[])) -- We must not get success with x->y! So we record that y is -- locally bound (with rnBndrR), and proceed. The Var case -- will fail when trying to bind x->y -} -- Everything else fails match menv subst e1 e2 = -- pprTrace "Failing at" ((text "e1:" <+> ppr e1) $$ (text "e2:" <+> ppr e2)) $ Nothing ------------------------------------------ match_var :: MatchEnv -> SubstEnv -> Var -- Template -> CoreExpr -- Target -> Maybe SubstEnv match_var menv subst@(tv_subst, id_subst, binds) v1 e2 | v1' `elemVarSet` me_tmpls menv = case lookupVarEnv id_subst v1' of Nothing | any (inRnEnvR rn_env) (varSetElems (exprFreeVars e2)) -> Nothing -- Occurs check failure -- e.g. match forall a. (\x-> a x) against (\y. y y) | otherwise -- No renaming to do on e2, because no free var -- of e2 is in the rnEnvR of the envt -- Note [Matching variable types] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- However, we must match the *types*; e.g. -- forall (c::Char->Int) (x::Char). -- f (c x) = "RULE FIRED" -- We must only match on args that have the right type -- It's actually quite difficult to come up with an example that shows -- you need type matching, esp since matching is left-to-right, so type -- args get matched first. But it's possible (e.g. simplrun008) and -- this is the Right Thing to do -> do { tv_subst' <- Unify.ruleMatchTyX menv tv_subst (idType v1') (exprType e2) -- c.f. match_ty below ; return (tv_subst', extendVarEnv id_subst v1' e2, binds) } Just e1' | tcEqExprX (nukeRnEnvL rn_env) e1' e2 -> Just subst | otherwise -> Nothing | otherwise -- v1 is not a template variable; check for an exact match with e2 = case e2 of Var v2 | v1' == rnOccR rn_env v2 -> Just subst other -> Nothing where rn_env = me_env menv v1' = rnOccL rn_env v1 -- If the template is -- forall x. f x (\x -> x) = ... -- Then the x inside the lambda isn't the -- template x, so we must rename first! ------------------------------------------ match_alts :: MatchEnv -> SubstEnv -> [CoreAlt] -- Template -> [CoreAlt] -- Target -> Maybe SubstEnv match_alts menv subst [] [] = return subst match_alts menv subst ((c1,vs1,r1):alts1) ((c2,vs2,r2):alts2) | c1 == c2 = do { subst1 <- match menv' subst r1 r2 ; match_alts menv subst1 alts1 alts2 } where menv' :: MatchEnv menv' = menv { me_env = rnBndrs2 (me_env menv) vs1 vs2 } match_alts menv subst alts1 alts2 = Nothing ------------------------------------------ match_ty :: MatchEnv -> SubstEnv -> Type -- Template -> Type -- Target -> Maybe SubstEnv match_ty menv (tv_subst, id_subst, binds) ty1 ty2 = do { tv_subst' <- Unify.ruleMatchTyX menv tv_subst ty1 ty2 ; return (tv_subst', id_subst, binds) } -- | Report partial matches for rules beginning with the specified -- string for the purposes of error reporting ruleCheckProgram :: (Activation -> Bool) -- ^ Rule activation test -> String -- ^ Rule pattern -> RuleBase -- ^ Database of rules -> [CoreBind] -- ^ Bindings to check in -> SDoc -- ^ Resulting check message ruleCheckProgram is_active rule_pat rule_base binds | isEmptyBag results = text "Rule check results: no rule application sites" | otherwise = vcat [text "Rule check results:", line, vcat [ p $$ line | p <- bagToList results ] ] where results = unionManyBags (map (ruleCheckBind (RuleCheckEnv is_active rule_pat rule_base)) binds) line = text (replicate 20 '-') data RuleCheckEnv = RuleCheckEnv { rc_is_active :: Activation -> Bool, rc_pattern :: String, rc_rule_base :: RuleBase } ruleCheckBind :: RuleCheckEnv -> CoreBind -> Bag SDoc -- The Bag returned has one SDoc for each call site found ruleCheckBind env (NonRec b r) = ruleCheck env r ruleCheckBind env (Rec prs) = unionManyBags [ruleCheck env r | (b,r) <- prs] ruleCheck :: RuleCheckEnv -> CoreExpr -> Bag SDoc ruleCheck env (Var v) = emptyBag ruleCheck env (Lit l) = emptyBag ruleCheck env (Type ty) = emptyBag ruleCheck env (App f a) = ruleCheckApp env (App f a) [] ruleCheck env (Note n e) = ruleCheck env e ruleCheck env (Cast e co) = ruleCheck env e ruleCheck env (Let bd e) = ruleCheckBind env bd `unionBags` ruleCheck env e ruleCheck env (Lam b e) = ruleCheck env e ruleCheck env (Case e _ _ as) = ruleCheck env e `unionBags` unionManyBags [ruleCheck env r | (_,_,r) <- as] ruleCheckApp env (App f a) as = ruleCheck env a `unionBags` ruleCheckApp env f (a:as) ruleCheckApp env (Var f) as = ruleCheckFun env f as ruleCheckApp env other as = ruleCheck env other ruleCheckFun :: RuleCheckEnv -> Id -> [CoreExpr] -> Bag SDoc -- Produce a report for all rules matching the predicate -- saying why it doesn't match the specified application ruleCheckFun env fn args | null name_match_rules = emptyBag | otherwise = unitBag (ruleAppCheck_help (rc_is_active env) fn args name_match_rules) where name_match_rules = filter match (getRules (rc_rule_base env) fn) match rule = (rc_pattern env) `isPrefixOf` unpackFS (ruleName rule) ruleAppCheck_help :: (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> SDoc ruleAppCheck_help is_active fn args rules = -- The rules match the pattern, so we want to print something vcat [text "Expression:" <+> ppr (mkApps (Var fn) args), vcat (map check_rule rules)] where n_args = length args i_args = args `zip` [1::Int ..] rough_args = map roughTopName args check_rule rule = rule_herald rule <> colon <+> rule_info rule rule_herald (BuiltinRule { ru_name = name }) = ptext (sLit "Builtin rule") <+> doubleQuotes (ftext name) rule_herald (Rule { ru_name = name }) = ptext (sLit "Rule") <+> doubleQuotes (ftext name) rule_info rule | Just _ <- matchRule noBlackList emptyInScopeSet args rough_args rule = text "matches (which is very peculiar!)" rule_info (BuiltinRule {}) = text "does not match" rule_info (Rule { ru_name = name, ru_act = act, ru_bndrs = rule_bndrs, ru_args = rule_args}) | not (is_active act) = text "active only in later phase" | n_args < n_rule_args = text "too few arguments" | n_mismatches == n_rule_args = text "no arguments match" | n_mismatches == 0 = text "all arguments match (considered individually), but rule as a whole does not" | otherwise = text "arguments" <+> ppr mismatches <+> text "do not match (1-indexing)" where n_rule_args = length rule_args n_mismatches = length mismatches mismatches = [i | (rule_arg, (arg,i)) <- rule_args `zip` i_args, not (isJust (match_fn rule_arg arg))] lhs_fvs = exprsFreeVars rule_args -- Includes template tyvars match_fn rule_arg arg = match menv emptySubstEnv rule_arg arg where in_scope = lhs_fvs `unionVarSet` exprFreeVars arg menv = ME { me_env = mkRnEnv2 (mkInScopeSet in_scope) , me_tmpls = mkVarSet rule_bndrs }