import Id
import Var ( Var, TyVar, mkCoVar, mkExportedLocalVar )
import IdInfo
-import NewDemand
+import Demand
import CoreSyn
import Unique
import PrelNames
wkr_arity = dataConRepArity data_con
wkr_info = noCafIdInfo
`setArityInfo` wkr_arity
- `setAllStrictnessInfo` Just wkr_sig
+ `setStrictnessInfo` Just wkr_sig
`setUnfoldingInfo` evaldUnfolding -- Record that it's evaluated,
-- even if arity = 0
-- It's important to specify the arity, so that partial
-- applications are treated as values
`setUnfoldingInfo` wrap_unf
- `setAllStrictnessInfo` Just wrap_sig
+ `setStrictnessInfo` Just wrap_sig
all_strict_marks = dataConExStricts data_con ++ dataConStrictMarks data_con
wrap_sig = mkStrictSig (mkTopDmdType arg_dmds cpr_info)
-- ...(let w = C x in ...(w p q)...)...
-- we want to see that w is strict in its two arguments
- wrap_unf = mkInlineRule InlSat wrap_rhs (length dict_args + length id_args)
+ wrap_unf = mkInlineRule needSaturated wrap_rhs (length dict_args + length id_args)
wrap_rhs = mkLams wrap_tvs $
mkLams eq_args $
mkLams dict_args $ mkLams id_args $
base_info = noCafIdInfo
`setArityInfo` 1
- `setAllStrictnessInfo` Just strict_sig
+ `setStrictnessInfo` Just strict_sig
`setUnfoldingInfo` (if no_unf then noUnfolding
else mkImplicitUnfolding rhs)
-- In module where class op is defined, we must add
| otherwise = Case (Var dict_id) dict_id (idType the_arg_id)
[(DataAlt data_con, eq_ids ++ arg_ids, Var the_arg_id)]
-dictSelRule :: Int -> Arity -> [CoreExpr] -> Maybe CoreExpr
+dictSelRule :: Int -> Arity -> IdUnfoldingFun -> [CoreExpr] -> Maybe CoreExpr
-- Oh, very clever
-- op_i t1..tk (df s1..sn d1..dm) = op_i_helper s1..sn d1..dm
-- op_i t1..tk (D t1..tk op1 ... opm) = opi
--
-- NB: the data constructor has the same number of type args as the class op
-dictSelRule index n_ty_args args
+dictSelRule index n_ty_args id_unf args
| (dict_arg : _) <- drop n_ty_args args
- , Just (_, _, val_args) <- exprIsConApp_maybe dict_arg
+ , Just (_, _, val_args) <- exprIsConApp_maybe id_unf dict_arg
= Just (val_args !! index)
| otherwise
= Nothing
info = noCafIdInfo
`setSpecInfo` mkSpecInfo (primOpRules prim_op name)
`setArityInfo` arity
- `setAllStrictnessInfo` Just strict_sig
+ `setStrictnessInfo` Just strict_sig
-- For each ccall we manufacture a separate CCallOpId, giving it
-- a fresh unique, a type that is correct for this particular ccall,
info = noCafIdInfo
`setArityInfo` arity
- `setAllStrictnessInfo` Just strict_sig
+ `setStrictnessInfo` Just strict_sig
(_, tau) = tcSplitForAllTys ty
(arg_tys, _) = tcSplitFunTys tau
, ru_try = match_seq_of_cast
}
-match_seq_of_cast :: [CoreExpr] -> Maybe CoreExpr
+match_seq_of_cast :: IdUnfoldingFun -> [CoreExpr] -> Maybe CoreExpr
-- See Note [Built-in RULES for seq]
-match_seq_of_cast [Type _, Type res_ty, Cast scrut co, expr]
+match_seq_of_cast _ [Type _, Type res_ty, Cast scrut co, expr]
= Just (Var seqId `mkApps` [Type (fst (coercionKind co)), Type res_ty,
scrut, expr])
-match_seq_of_cast _ = Nothing
+match_seq_of_cast _ _ = Nothing
------------------------------------------------
lazyId :: Id -- See Note [lazyId magic]
pc_bottoming_Id name ty
= pcMiscPrelId name ty bottoming_info
where
- bottoming_info = vanillaIdInfo `setAllStrictnessInfo` Just strict_sig
+ bottoming_info = vanillaIdInfo `setStrictnessInfo` Just strict_sig
`setArityInfo` 1
-- Make arity and strictness agree