\begin{code}
module TcRules ( tcRules ) where
-#include "HsVersions.h"
-
import HsSyn
import TcRnMonad
import TcSimplify
import Name
import SrcLoc
import Outputable
+import FastString
\end{code}
+Note [Typechecking rules]
+~~~~~~~~~~~~~~~~~~~~~~~~~
+We *infer* the typ of the LHS, and use that type to *check* the type of
+the RHS. That means that higher-rank rules work reasonably well. Here's
+an example (test simplCore/should_compile/rule2.hs) produced by Roman:
+
+ foo :: (forall m. m a -> m b) -> m a -> m b
+ foo f = ...
+
+ bar :: (forall m. m a -> m a) -> m a -> m a
+ bar f = ...
+
+ {-# RULES "foo/bar" foo = bar #-}
+
+He wanted the rule to typecheck.
+
\begin{code}
tcRules :: [LRuleDecl Name] -> TcM [LRuleDecl TcId]
-tcRules decls = mappM (wrapLocM tcRule) decls
+tcRules decls = mapM (wrapLocM tcRule) decls
tcRule :: RuleDecl Name -> TcM (RuleDecl TcId)
tcRule (HsRule name act vars lhs fv_lhs rhs fv_rhs)
- = addErrCtxt (ruleCtxt name) $
- traceTc (ptext SLIT("---- Rule ------")
- <+> ppr name) `thenM_`
- newFlexiTyVarTy openTypeKind `thenM` \ rule_ty ->
+ = addErrCtxt (ruleCtxt name) $ do
+ traceTc (ptext (sLit "---- Rule ------") <+> ppr name)
-- Deal with the tyvars mentioned in signatures
- tcRuleBndrs vars (\ ids ->
- -- Now LHS and RHS
- getLIE (tcMonoExpr lhs rule_ty) `thenM` \ (lhs', lhs_lie) ->
- getLIE (tcMonoExpr rhs rule_ty) `thenM` \ (rhs', rhs_lie) ->
- returnM (ids, lhs', rhs', lhs_lie, rhs_lie)
- ) `thenM` \ (ids, lhs', rhs', lhs_lie, rhs_lie) ->
+ (ids, lhs', rhs', lhs_lie, rhs_lie, rule_ty) <-
+ tcRuleBndrs vars $ \ ids -> do
+ -- Now LHS and RHS; see Note [Typechecking rules]
+ ((lhs', rule_ty), lhs_lie) <- getLIE (tcInferRho lhs)
+ (rhs', rhs_lie) <- getLIE (tcMonoExpr rhs rule_ty)
+ return (ids, lhs', rhs', lhs_lie, rhs_lie, rule_ty)
-- Check that LHS has no overloading at all
- tcSimplifyRuleLhs lhs_lie `thenM` \ (lhs_dicts, lhs_binds) ->
+ (lhs_dicts, lhs_binds) <- tcSimplifyRuleLhs lhs_lie
-- Gather the template variables and tyvars
let
-- during zonking (see TcHsSyn.zonkRule)
--
forall_tvs = tyVarsOfTypes (rule_ty : map idType tpl_ids)
- in
+
-- RHS can be a bit more lenient. In particular,
-- we let constant dictionaries etc float outwards
--
-- NB: tcSimplifyInferCheck zonks the forall_tvs, and
-- knocks out any that are constrained by the environment
- getInstLoc (SigOrigin (RuleSkol name)) `thenM` \ loc ->
- tcSimplifyInferCheck loc
- forall_tvs
- lhs_dicts rhs_lie `thenM` \ (forall_tvs1, rhs_binds) ->
- zonkQuantifiedTyVars forall_tvs1 `thenM` \ forall_tvs2 ->
- -- This zonk is exactly the same as the one in TcBinds.generalise
-
- returnM (HsRule name act
- (map (RuleBndr . noLoc) (forall_tvs2 ++ tpl_ids)) -- yuk
+ loc <- getInstLoc (SigOrigin (RuleSkol name))
+ (forall_tvs1, rhs_binds) <- tcSimplifyInferCheck loc
+ forall_tvs
+ lhs_dicts rhs_lie
+
+ return (HsRule name act
+ (map (RuleBndr . noLoc) (forall_tvs1 ++ tpl_ids)) -- yuk
(mkHsDictLet lhs_binds lhs') fv_lhs
(mkHsDictLet rhs_binds rhs') fv_rhs)
-
+tcRuleBndrs :: [RuleBndr Name] -> ([Id] -> TcM a) -> TcM a
tcRuleBndrs [] thing_inside = thing_inside []
tcRuleBndrs (RuleBndr var : vars) thing_inside
= do { ty <- newFlexiTyVarTy openTypeKind
tcExtendIdEnv [id] $
tcRuleBndrs vars (\ids -> thing_inside (id:ids)) }
-ruleCtxt name = ptext SLIT("When checking the transformation rule") <+>
+ruleCtxt :: FastString -> SDoc
+ruleCtxt name = ptext (sLit "When checking the transformation rule") <+>
doubleQuotes (ftext name)
\end{code}