import CoreUtils ( exprType, exprIsHNF )
import CoreArity ( exprArity )
import Var
-import Id ( idType, isOneShotLambda, idUnfolding,
- setIdStrictness, mkWorkerId, setInlinePragma,
- setInlineActivation, setIdUnfolding,
- setIdArity )
+import Id
import Type ( Type )
import IdInfo
import Demand ( Demand(..), StrictSig(..), DmdType(..), DmdResult(..),
| otherwise = thing_inside
where
- unfolding = idUnfolding fn_id
- inline_rule = mkInlineRule unSaturatedOk rhs (unfoldingArity unfolding)
+ unfolding = idUnfolding fn_id
+ inline_rule = mkInlineRule rhs Nothing
---------------------
splitFun :: Id -> IdInfo -> [Demand] -> DmdResult -> Expr Var
; let
work_rhs = work_fn rhs
work_id = mkWorkerId work_uniq fn_id (exprType work_rhs)
+ `setIdOccInfo` occInfo fn_info
+ -- Copy over occurrence info from parent
+ -- Notably whether it's a loop breaker
+ -- Doesn't matter much, since we will simplify next, but
+ -- seems right-er to do so
+
`setInlineActivation` (inlinePragmaActivation inl_prag)
-- Any inline activation (which sets when inlining is active)
-- on the original function is duplicated on the worker
wrap_rhs = wrap_fn work_id
wrap_prag = InlinePragma { inl_inline = True
+ , inl_sat = Nothing
, inl_act = ActiveAfter 0
, inl_rule = rule_match_info }
+ -- See Note [Wrapper activation]
+ -- The RuleMatchInfo is (and must be) unaffected
+ -- The inl_inline is bound to be False, else we would not be
+ -- making a wrapper
wrap_id = fn_id `setIdUnfolding` mkWwInlineRule work_id wrap_rhs arity
`setInlinePragma` wrap_prag
- -- See Note [Wrapper activation]
- -- The RuleMatchInfo is (and must be) unaffected
- -- The inl_inline is bound to be False, else we would not be
- -- making a wrapper
+ `setIdOccInfo` NoOccInfo
+ -- Zap any loop-breaker-ness, to avoid bleating from Lint
+ -- about a loop breaker with an INLINE rule
; return ([(work_id, work_rhs), (wrap_id, wrap_rhs)]) })
-- Worker first, because wrapper mentions it