import TcType
import Type
+import Coercion
import TysPrim ( anyTypeOfKind )
import CostCentre
import Module
import Bag
import BasicTypes hiding ( TopLevel )
import FastString
--- import StaticFlags ( opt_DsMultiTyVar )
import Util
import MonadUtils
dsHsBind :: AutoScc -> HsBind Id -> DsM (OrdList (Id,CoreExpr))
dsHsBind _ (VarBind { var_id = var, var_rhs = expr, var_inline = inline_regardless })
- = do { core_expr <- dsLExpr expr
+ = do { core_expr <- dsLExpr expr
-- Dictionary bindings are always VarBinds,
-- so we only need do this here
; let var' | inline_regardless = var `setIdUnfolding` mkCompulsoryUnfolding core_expr'
| otherwise = var
- ; return (unitOL (var', core_expr')) }
+ ; return (unitOL (makeCorePair var' False 0 core_expr')) }
-dsHsBind _ (FunBind { fun_id = L _ fun, fun_matches = matches
+dsHsBind auto_scc (FunBind { fun_id = L _ fun, fun_matches = matches
, fun_co_fn = co_fn, fun_tick = tick
, fun_infix = inf })
= do { (args, body) <- matchWrapper (FunRhs (idName fun) inf) matches
; body' <- mkOptTickBox tick body
; wrap_fn' <- dsHsWrapper co_fn
- ; let rhs = wrap_fn' (mkLams args body')
+ ; let rhs = addAutoScc auto_scc fun $ wrap_fn' (mkLams args body')
; return (unitOL (makeCorePair fun False 0 rhs)) }
-dsHsBind _ (PatBind { pat_lhs = pat, pat_rhs = grhss, pat_rhs_ty = ty })
+dsHsBind auto_scc (PatBind { pat_lhs = pat, pat_rhs = grhss, pat_rhs_ty = ty })
= do { body_expr <- dsGuarded grhss ty
; sel_binds <- mkSelectorBinds pat body_expr
-- We silently ignore inline pragmas; no makeCorePair
-- Not so cool, but really doesn't matter
- ; return (toOL sel_binds) }
+ ; let sel_binds' = [ (v, addAutoScc auto_scc v expr)
+ | (v, expr) <- sel_binds ]
+ ; return (toOL sel_binds') }
-- A common case: one exported variable
-- Non-recursive bindings come through this way
free_vars_of :: EvTerm -> [EvVar]
free_vars_of (EvId v) = [v]
- free_vars_of (EvCast v co) = v : varSetElems (tyVarsOfType co)
- free_vars_of (EvCoercion co) = varSetElems (tyVarsOfType co)
+ free_vars_of (EvCast v co) = v : varSetElems (tyCoVarsOfCo co)
+ free_vars_of (EvCoercion co) = varSetElems (tyCoVarsOfCo co)
free_vars_of (EvDFunApp _ _ vs) = vs
free_vars_of (EvSuperClass d _) = [d]
(arg_tys, _) = splitFunTys rho
bndrs = ex_tvs ++ map mk_wild_pred (theta `zip` [0..])
++ map mkWildValBinder arg_tys
- mk_wild_pred (p, i) | i==n = ASSERT( p `tcEqPred` (coVarPred co_var))
+ mk_wild_pred (p, i) | i==n = ASSERT( p `eqPred` (coVarPred co_var))
co_var
| otherwise = mkWildEvBinder p
ds_pair (EvBind v r) = (v, dsEvTerm r)
dsEvTerm :: EvTerm -> CoreExpr
-dsEvTerm (EvId v) = Var v
-dsEvTerm (EvCast v co) = Cast (Var v) co
+dsEvTerm (EvId v) = Var v
+dsEvTerm (EvCast v co) = Cast (Var v) co
dsEvTerm (EvDFunApp df tys vars) = Var df `mkTyApps` tys `mkVarApps` vars
-dsEvTerm (EvCoercion co) = Type co
+dsEvTerm (EvCoercion co) = Coercion co
dsEvTerm (EvSuperClass d n)
= ASSERT( isClassPred (classSCTheta cls !! n) )
-- We can only select *dictionary* superclasses
-> Located TcSpecPrag
-> DsM (Maybe (OrdList (Id,CoreExpr), CoreRule))
dsSpec mb_poly_rhs (L loc (SpecPrag poly_id spec_co spec_inl))
+ | isJust (isClassOpId_maybe poly_id)
+ = putSrcSpanDs loc $
+ do { warnDs (ptext (sLit "Ignoring useless SPECIALISE pragma for class method selector")
+ <+> quotes (ppr poly_id))
+ ; return Nothing } -- There is no point in trying to specialise a class op
+ -- Moreover, classops don't (currently) have an inl_sat arity set
+ -- (it would be Just 0) and that in turn makes makeCorePair bleat
+
+ | otherwise
= putSrcSpanDs loc $
do { let poly_name = idName poly_id
; spec_name <- newLocalName poly_name
; wrap_fn <- dsHsWrapper spec_co
; let (bndrs, ds_lhs) = collectBinders (wrap_fn (Var poly_id))
spec_ty = mkPiTypes bndrs (exprType ds_lhs)
- ; case decomposeRuleLhs ds_lhs of {
- Nothing -> do { warnDs (decomp_msg spec_co)
- ; return Nothing } ;
-
- Just (_fn, args) ->
-
- -- Check for dead binders: Note [Unused spec binders]
- let arg_fvs = exprsFreeVars args
- bad_bndrs = filterOut (`elemVarSet` arg_fvs) bndrs
- in if not (null bad_bndrs)
- then do { warnDs (dead_msg bad_bndrs); return Nothing }
- else do
+ ; case decomposeRuleLhs bndrs ds_lhs of {
+ Left msg -> do { warnDs msg; return Nothing } ;
+ Right (final_bndrs, _fn, args) -> do
{ (spec_unf, unf_pairs) <- specUnfolding wrap_fn spec_ty (realIdUnfolding poly_id)
`setInlinePragma` inl_prag
`setIdUnfolding` spec_unf
inl_prag | isDefaultInlinePragma spec_inl = idInlinePragma poly_id
- | otherwise = spec_inl
+ | otherwise = spec_inl
-- Get the INLINE pragma from SPECIALISE declaration, or,
-- failing that, from the original Id
- extra_dict_bndrs = [ mkLocalId (localiseName (idName d)) (idType d)
- -- See Note [Constant rule dicts]
- | d <- varSetElems (arg_fvs `delVarSetList` bndrs)
- , isDictId d]
-
rule = mkRule False {- Not auto -} is_local_id
(mkFastString ("SPEC " ++ showSDoc (ppr poly_name)))
AlwaysActive poly_name
- (extra_dict_bndrs ++ bndrs) args
+ final_bndrs args
(mkVarApps (Var spec_id) bndrs)
spec_rhs = wrap_fn poly_rhs
; return (Just (spec_pair `consOL` unf_pairs, rule))
} } }
where
- dead_msg bs = vcat [ sep [ptext (sLit "Useless constraint") <> plural bs
- <+> ptext (sLit "in specialied type:"),
- nest 2 (pprTheta (map get_pred bs))]
- , ptext (sLit "SPECIALISE pragma ignored")]
- get_pred b = ASSERT( isId b ) expectJust "dsSpec" (tcSplitPredTy_maybe (idType b))
-
- decomp_msg spec_co
- = hang (ptext (sLit "Specialisation too complicated to desugar; ignored"))
- 2 (pprHsWrapper (ppr poly_id) spec_co)
-
is_local_id = isJust mb_poly_rhs
poly_rhs | Just rhs <- mb_poly_rhs
- = rhs
- | Just unfolding <- maybeUnfoldingTemplate (idUnfolding poly_id)
- = unfolding
+ = rhs -- Local Id; this is its rhs
+ | Just unfolding <- maybeUnfoldingTemplate (realIdUnfolding poly_id)
+ = unfolding -- Imported Id; this is its unfolding
+ -- Use realIdUnfolding so we get the unfolding
+ -- even when it is a loop breaker.
+ -- We want to specialise recursive functions!
| otherwise = pprPanic "dsImpSpecs" (ppr poly_id)
- -- In the Nothing case the specialisation is for an imported Id
- -- whose unfolding gives the RHS to be specialised
- -- The type checker has checked that it has an unfolding
+ -- The type checker has checked that it *has* an unfolding
specUnfolding :: (CoreExpr -> CoreExpr) -> Type
-> Unfolding -> DsM (Unfolding, OrdList (Id,CoreExpr))
+{- [Dec 10: TEMPORARILY commented out, until we can straighten out how to
+ generate unfoldings for specialised DFuns
+
specUnfolding wrap_fn spec_ty (DFunUnfolding _ _ ops)
= do { let spec_rhss = map wrap_fn ops
; spec_ids <- mapM (mkSysLocalM (fsLit "spec") . exprType) spec_rhss
; return (mkDFunUnfolding spec_ty (map Var spec_ids), toOL (spec_ids `zip` spec_rhss)) }
+-}
specUnfolding _ _ _
= return (noUnfolding, nilOL)
-{-
-mkArbitraryTypeEnv :: [TyVar] -> [([TyVar], a, b, c)] -> TyVarEnv Type
--- If any of the tyvars is missing from any of the lists in
--- the second arg, return a binding in the result
-mkArbitraryTypeEnv tyvars exports
- = go emptyVarEnv exports
- where
- go env [] = env
- go env ((ltvs, _, _, _) : exports)
- = go env' exports
- where
- env' = foldl extend env [tv | tv <- tyvars
- , not (tv `elem` ltvs)
- , not (tv `elemVarEnv` env)]
-
- extend env tv = extendVarEnv env tv (dsMkArbitraryType tv)
--}
-
dsMkArbitraryType :: TcTyVar -> Type
dsMkArbitraryType tv = anyTypeOfKind (tyVarKind tv)
\end{code}
-Note [Unused spec binders]
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider
- f :: a -> a
- {-# SPECIALISE f :: Eq a => a -> a #-}
-It's true that this *is* a more specialised type, but the rule
-we get is something like this:
- f_spec d = f
- RULE: f = f_spec d
-Note that the rule is bogus, becuase it mentions a 'd' that is
-not bound on the LHS! But it's a silly specialisation anyway, becuase
-the constraint is unused. We could bind 'd' to (error "unused")
-but it seems better to reject the program because it's almost certainly
-a mistake. That's what the isDeadBinder call detects.
-
-Note [Constant rule dicts]
-~~~~~~~~~~~~~~~~~~~~~~~
-When the LHS of a specialisation rule, (/\as\ds. f es) has a free dict,
-which is presumably in scope at the function definition site, we can quantify
-over it too. *Any* dict with that type will do.
-
-So for example when you have
- f :: Eq a => a -> a
- f = <rhs>
- {-# SPECIALISE f :: Int -> Int #-}
-
-Then we get the SpecPrag
- SpecPrag (f Int dInt)
-
-And from that we want the rule
-
- RULE forall dInt. f Int dInt = f_spec
- f_spec = let f = <rhs> in f Int dInt
-
-But be careful! That dInt might be GHC.Base.$fOrdInt, which is an External
-Name, and you can't bind them in a lambda or forall without getting things
-confused. Likewise it might have an InlineRule or something, which would be
-utterly bogus. So we really make a fresh Id, with the same unique and type
-as the old one, but with an Internal name and no IdInfo.
-
%************************************************************************
%* *
\subsection{Adding inline pragmas}
%************************************************************************
\begin{code}
-decomposeRuleLhs :: CoreExpr -> Maybe (Id, [CoreExpr])
+decomposeRuleLhs :: [Var] -> CoreExpr -> Either SDoc ([Var], Id, [CoreExpr])
-- Take apart the LHS of a RULE. It's suuposed to look like
-- /\a. f a Int dOrdInt
-- or /\a.\d:Ord a. let { dl::Ord [a] = dOrdList a d } in f [a] dl
-- That is, the RULE binders are lambda-bound
-- Returns Nothing if the LHS isn't of the expected shape
-decomposeRuleLhs lhs
+decomposeRuleLhs bndrs lhs
= -- Note [Simplifying the left-hand side of a RULE]
- case collectArgs (simpleOptExpr lhs) of
- (Var fn, args) -> Just (fn, args)
+ case collectArgs opt_lhs of
+ (Var fn, args) -> check_bndrs fn args
(Case scrut bndr ty [(DEFAULT, _, body)], args)
| isDeadBinder bndr -- Note [Matching seqId]
- -> Just (seqId, args' ++ args)
+ -> check_bndrs seqId (args' ++ args)
where
args' = [Type (idType bndr), Type ty, scrut, body]
- _other -> Nothing -- Unexpected shape
+ _other -> Left bad_shape_msg
+ where
+ opt_lhs = simpleOptExpr lhs
+
+ check_bndrs fn args
+ | null (dead_bndrs) = Right (extra_dict_bndrs ++ bndrs, fn, args)
+ | otherwise = Left (vcat (map dead_msg dead_bndrs))
+ where
+ arg_fvs = exprsFreeVars args
+
+ -- Check for dead binders: Note [Unused spec binders]
+ dead_bndrs = filterOut (`elemVarSet` arg_fvs) bndrs
+
+ -- Add extra dict binders: Note [Constant rule dicts]
+ extra_dict_bndrs = [ mkLocalId (localiseName (idName d)) (idType d)
+ | d <- varSetElems (arg_fvs `delVarSetList` bndrs)
+ , isDictId d]
+
+
+ bad_shape_msg = hang (ptext (sLit "RULE left-hand side too complicated to desugar"))
+ 2 (ppr opt_lhs)
+ dead_msg bndr = hang (sep [ ptext (sLit "Forall'd") <+> pp_bndr bndr
+ , ptext (sLit "is not bound in RULE lhs")])
+ 2 (ppr opt_lhs)
+ pp_bndr bndr
+ | isTyVar bndr = ptext (sLit "type variable") <+> quotes (ppr bndr)
+ | isEvVar bndr = ptext (sLit "constraint") <+> quotes (ppr (evVarPred bndr))
+ | otherwise = ptext (sLit "variable") <+> quotes (ppr bndr)
\end{code}
Note [Simplifying the left-hand side of a RULE]
NB: tcSimplifyRuleLhs is very careful not to generate complicated
dictionary expressions that we might have to match
-
Note [Matching seqId]
~~~~~~~~~~~~~~~~~~~
The desugarer turns (seq e r) into (case e of _ -> r), via a special-case hack
and this code turns it back into an application of seq!
See Note [Rules for seq] in MkId for the details.
+Note [Unused spec binders]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider
+ f :: a -> a
+ {-# SPECIALISE f :: Eq a => a -> a #-}
+It's true that this *is* a more specialised type, but the rule
+we get is something like this:
+ f_spec d = f
+ RULE: f = f_spec d
+Note that the rule is bogus, becuase it mentions a 'd' that is
+not bound on the LHS! But it's a silly specialisation anyway, becuase
+the constraint is unused. We could bind 'd' to (error "unused")
+but it seems better to reject the program because it's almost certainly
+a mistake. That's what the isDeadBinder call detects.
+
+Note [Constant rule dicts]
+~~~~~~~~~~~~~~~~~~~~~~~
+When the LHS of a specialisation rule, (/\as\ds. f es) has a free dict,
+which is presumably in scope at the function definition site, we can quantify
+over it too. *Any* dict with that type will do.
+
+So for example when you have
+ f :: Eq a => a -> a
+ f = <rhs>
+ {-# SPECIALISE f :: Int -> Int #-}
+
+Then we get the SpecPrag
+ SpecPrag (f Int dInt)
+
+And from that we want the rule
+
+ RULE forall dInt. f Int dInt = f_spec
+ f_spec = let f = <rhs> in f Int dInt
+
+But be careful! That dInt might be GHC.Base.$fOrdInt, which is an External
+Name, and you can't bind them in a lambda or forall without getting things
+confused. Likewise it might have an InlineRule or something, which would be
+utterly bogus. So we really make a fresh Id, with the same unique and type
+as the old one, but with an Internal name and no IdInfo.
+
%************************************************************************
%* *
projects / ghc-hetmet.git / blobdiff