import RnExpr ( rnExpr )
import RdrHsSyn ( RdrNameHsExpr, RdrNameHsDecl )
import RnHsSyn ( RenamedHsExpr )
-import TcExpr ( tcCheckRho )
+import TcExpr ( tcCheckRho, tcMonoExpr )
import TcHsSyn ( TcExpr, TypecheckedHsExpr, mkHsLet, zonkTopExpr )
import TcSimplify ( tcSimplifyTop, tcSimplifyBracket )
-import TcUnify ( unifyTauTy )
+import TcUnify ( Expected, unifyTauTy, zapExpectedTo, zapExpectedType )
import TcType ( TcType, openTypeKind, mkAppTy )
import TcEnv ( spliceOK, tcMetaTy, tcWithTempInstEnv, bracketOK )
import TcRnTypes ( TopEnv(..) )
-import TcMType ( newTyVarTy, zapToType, UserTypeCtxt(ExprSigCtxt) )
+import TcMType ( newTyVarTy, UserTypeCtxt(ExprSigCtxt) )
import TcMonoType ( tcHsSigType )
import Name ( Name )
import TcRnMonad
import TysWiredIn ( mkListTy )
-import DsMeta ( exprTyConName, declTyConName, typeTyConName, decTyConName, qTyConName )
+import DsMeta ( expQTyConName, decQTyConName, typeQTyConName, decTyConName, qTyConName )
import ErrUtils (Message)
import Outputable
import Panic ( showException )
tcSpliceExpr :: Name
-> RenamedHsExpr
- -> TcType
+ -> Expected TcType
-> TcM TcExpr
#ifndef GHCI
%************************************************************************
\begin{code}
-tcBracket :: HsBracket Name -> TcType -> TcM TcExpr
+tcBracket :: HsBracket Name -> Expected TcType -> TcM TcExpr
tcBracket brack res_ty
= getStage `thenM` \ level ->
case bracketOK level of {
) `thenM` \ (meta_ty, lie) ->
tcSimplifyBracket lie `thenM_`
- unifyTauTy res_ty meta_ty `thenM_`
+ -- Make the expected type have the right shape
+ zapExpectedTo res_ty meta_ty `thenM_`
-- Return the original expression, not the type-decorated one
readMutVar pending_splices `thenM` \ pendings ->
tc_bracket (ExpBr expr)
= newTyVarTy openTypeKind `thenM` \ any_ty ->
tcCheckRho expr any_ty `thenM_`
- tcMetaTy exprTyConName
+ tcMetaTy expQTyConName
-- Result type is Expr (= Q Exp)
tc_bracket (TypBr typ)
= tcHsSigType ExprSigCtxt typ `thenM_`
- tcMetaTy typeTyConName
+ tcMetaTy typeQTyConName
-- Result type is Type (= Q Typ)
tc_bracket (DecBr decls)
-- Here (h 4) :: Q Exp
-- but $(h 4) :: forall a.a i.e. anything!
- zapToType res_ty `thenM_`
- tcMetaTy exprTyConName `thenM` \ meta_exp_ty ->
+ zapExpectedType res_ty `thenM_`
+ tcMetaTy expQTyConName `thenM` \ meta_exp_ty ->
setStage (Splice next_level) (
setLIEVar lie_var $
tcCheckRho expr meta_exp_ty
-- Note that we do not decrement the level (to -1) before
-- typechecking the expression. For example:
-- f x = $( ...$(g 3) ... )
--- The recursive call to tcCheckRho will simply expand the
+-- The recursive call to tcMonoExpr will simply expand the
-- inner escape before dealing with the outer one
tcTopSplice expr res_ty
- = tcMetaTy exprTyConName `thenM` \ meta_exp_ty ->
+ = tcMetaTy expQTyConName `thenM` \ meta_exp_ty ->
-- Typecheck the expression
tcTopSpliceExpr expr meta_exp_ty `thenM` \ zonked_q_expr ->
initRn SourceMode (rnExpr expr2) `thenM` \ (exp3, fvs) ->
importSupportingDecls fvs `thenM` \ env ->
- setGblEnv env (tcCheckRho exp3 res_ty)
+ setGblEnv env (tcMonoExpr exp3 res_ty)
tcTopSpliceExpr :: RenamedHsExpr -> TcType -> TcM TypecheckedHsExpr