+import GHC.Types.Basic  ( CompilerPhase )

+  | CoreDoRuleCheck CompilerPhase String  -- Check for non-application of rules

+                                       -- matching this string

+        SimplPhase(..), isActive,

+definitions of `updModeForStableUnfoldings` and `updModeForRule{LHS,RHS}` in

+sePhase :: SimplEnv -> SimplPhase

+  { sm_phase        :: !SimplPhase    -- ^ The phase of the simplifier

+-- | See Note [SimplPhase]

+data SimplPhase

+  -- | A simplifier phase: InitialPhase, Phase 2, Phase 1, Phase 0, FinalPhase

+  = SimplPhase CompilerPhase

+  -- | Simplifying the RHS of a rule or of a stable unfolding: the range of

+  -- phases of the activation of the rule/stable unfolding.

+  --

+  -- _Invariant:_ 'simplStartPhase' is not a later phase than 'simplEndPhase'.

+  -- Equivalently, 'SimplPhaseRange' is always a non-empty interval of phases.

+  --

+  -- See Note [What is active in the RHS of a RULE?] in GHC.Core.Opt.Simplify.Utils.

+  | SimplPhaseRange

+      { simplStartPhase :: CompilerPhase

+      , simplEndPhase   :: CompilerPhase

+      }

+

+  deriving Eq

+

+instance Outputable SimplPhase where

+  ppr (SimplPhase p) = ppr p

+  ppr (SimplPhaseRange s e) = brackets $ ppr s <> text "..." <> ppr e

+

+-- | Is this activation active in this simplifier phase?

+--

+-- For a phase range, @isActive simpl_phase_range act@ is true if and only if

+-- @act@ is active throughout the entire range, as per

+-- Note [What is active in the RHS of a RULE?] in GHC.Core.Opt.Simplify.Utils.

+--

+-- See Note [SimplPhase].

+isActive :: SimplPhase -> Activation -> Bool

+isActive (SimplPhase p) act = isActiveInPhase p act

+isActive (SimplPhaseRange start end) act =

+  -- To check whether the activation is active throughout the whole phase range,

+  -- it's sufficient to check the endpoints of the phase range, because an

+  -- activation can never have gaps (all activations are phase intervals).

+  isActiveInPhase start act && isActiveInPhase end act

+

+{- Note [SimplPhase]

+~~~~~~~~~~~~~~~~~~~~

+In general, the simplifier is invoked in successive phases:

+

+  InitialPhase, Phase 2, Phase 1, Phase 0, FinalPhase

+

+This allows us to control which rules, specialisations and inlinings are

+active at any given point. For example,

+

+  {-# RULE "myRule" [1] lhs = rhs #-}

+

+starts being active in Phase 1, and stays active thereafter. Thus it is active

+in Phase 1, Phase 0, FinalPhase, but not active in InitialPhase or Phase 2.

+

+This simplifier phase is stored in the sm_phase field of SimplMode, usin

+the 'SimplPhase' constructor. This allows us to determine which rules/inlinings

+are active.

+

+When we invoke the simplifier on the RHS of a rule, such as 'rhs' above, instead

+of setting the simplifier mode to a single phase, we use a phase range

+corresponding to the range of phases in which the rule is active, with the

+'SimplPhaseRange' constructor. This allows us to check whether other rules or

+inlinings are active throughout the whole activation of the rule.

+See Note [What is active in the RHS of a RULE?] in GHC.Core.Opt.Simplify.Utils.

+-}

+

+    ppr (SimplMode { sm_phase = phase , sm_names = ss

+         sep [ text "Phase =" <+> ppr phase <+>

+{- Note [Local floating]

+~~~~~~~~~~~~~~~~~~~~~~~~

+import GHC.Types.Basic  ( Arity, RecFlag(..) )

+  =  isActive (sm_phase mode) (idInlineActivation id)

+              sep [text "Inlining done:", nest 4 (ppr var)]

+            --  $$ nest 2 (vcat

+            --       [ text "Simplifier phase:" <+> ppr (sePhase env)

+            --       , text "Unfolding activation:" <+> ppr (idInlineActivation var)

+            --       ])

+        --, text "Simplifier phase:" <+> ppr (sePhase env)

+        --, text "Rule activation:" <+> ppr (ruleActivation rule)

+

+    -- See Note [Simplifying rules] and Note [What is active in the RHS of a RULE?]

+    -- in GHC.Core.Opt.Simplify.Utils.

+                 lhs_env = updMode updModeForRuleLHS env'

+                 rhs_env = updMode (updModeForRuleRHS act) env'

+

+        updModeForStableUnfoldings, updModeForRuleLHS, updModeForRuleRHS,

+which it is on the LHS of a rule (see updModeForRuleLHS), then don't

+-- See Note [Simplifying inside stable unfoldings]

+  = current_mode

+    { sm_phase = phaseFromActivation (sm_phase current_mode) unf_act

+        -- See Note [What is active in the RHS of a RULE?]

+    , sm_eta_expand = False

+        -- See Note [Eta expansion in stable unfoldings and rules]

+    , sm_inline     = True

+   -- sm_rules: just inherit; sm_rules might be "off" because of -fno-enable-rewrite-rules

+    }

+updModeForRuleLHS :: SimplMode -> SimplMode

+updModeForRuleLHS current_mode

+  = current_mode { sm_phase        = SimplPhase InitialPhase -- doesn't matter

+updModeForRuleRHS :: Activation -> SimplMode -> SimplMode

+updModeForRuleRHS rule_act current_mode =

+  current_mode

+    -- See Note [What is active in the RHS of a RULE?]

+    { sm_phase = phaseFromActivation (sm_phase current_mode) rule_act

+    , sm_eta_expand = False

+        -- See Note [Eta expansion in stable unfoldings and rules]

+    }

+

+-- | Compute the phase range to set the 'SimplMode' to

+-- when simplifying the RHS of a rule or of a stable unfolding.

+--

+-- See Note [What is active in the RHS of a RULE?]

+phaseFromActivation

+  :: SimplPhase -- ^ the current simplifier phase

+  -> Activation -- ^ the activation of the RULE or stable unfolding

+  -> SimplPhase

+phaseFromActivation p act

+  | isNeverActive act

+  = p

+  | otherwise

+  = SimplPhaseRange act_start act_end

+  where

+    act_start = beginPhase act

+    act_end   = endPhase   act

+

+~~~~~~~~~~~~~~~~~~~~~~~~~~~

+So we switch off cast swizzling in updModeForRuleLHS.

+Note [What is active in the RHS of a RULE?]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Suppose we have either a RULE or an inline pragma with an explicit activation:

+

+  {-# RULE "R" [p] lhs = rhs #-}

+  {-# INLINE [p] foo #-}

+

+We should do some modest rules/inlining stuff in the right-hand sides, partly to

+eliminate senseless crap, and partly to break the recursive knots generated by

+instance declarations. However, we have to be careful about precisely which

+rules/inlinings are active. In particular:

+

+  a) Rules/inlinings that *cease* being active before p should not apply.

+  b) Rules/inlinings that only become active *after* p should also not apply.

+

+In the rest of this Note, we will focus on rules, but everything applies equally

+to the RHSs of stable unfoldings.

+

+Our carefully crafted plan is as follows:

+

+  -------------------------------------------------------------

+  When simplifying the RHS of a RULE R with activation range A,

+  fire only other rules R' that are active throughout all of A.

+  -------------------------------------------------------------

+

+Reason: R might fire in any phase in A. Then R' can fire only if R' is active

+in that phase. If not, it's not safe to unconditionally fire R' in the RHS of R.

+

+This plan is implemented by:

+

+  1. Setting the simplifier phase to the range of phases

+     corresponding to the start/end phases of the rule's activation.

+  2. When checking whether another rule is active, we use the function

+       isActive :: SimplPhase -> Activation -> Bool

+     from GHC.Core.Opt.Simplify.Env, which checks whether the other rule is

+     active throughout the whole range of phases.

+

+However, if the rule whose RHS we are simplifying is never active, instead of

+setting the phase range to an empty interval, we keep the current simplifier

+phase. This special case avoids firing ALL rules in the RHS of a never-active

+rule.

+

+You might wonder about a situation such as the following:

+

+  module M1 where

+    {-# RULES "r1" [1] lhs1 = rhs1 #-}

+    {-# RULES "r2" [2] lhs2 = rhs2 #-}

+

+    Current simplifier phase: 1

+

+It looks tempting to use "r1" when simplifying the RHS of "r2", yet we

+**must not** do so: for any module M that imports M1, we are going to start

+simplification in M starting at InitialPhase, and we will see the

+fully simplified rules RHSs imported from M1.

+Conclusion: stick to the plan.

+

+Second, we must be careful when simplifying the RHS that we do not apply RULES

+which are not active over the whole active range of the stable unfolding.

+This is all explained in Note [What is active in the RHS of a RULE?].

+    id_unf   = whenActiveUnfoldingFun (isActive (sePhase env))

+    active = isActive (sePhase env)

+           $ inlinePragmaActivation inline_prag

+    early_phase =

+      case sePhase env of

+        SimplPhase p -> p /= FinalPhase

+        SimplPhaseRange _start end -> end /= FinalPhase

+    -- Hence the final phase test: until the final phase, we take no special

+    -- notice of top level things, but then we become more leery about inlining

+    active      = isActive (sePhase env) $ idInlineActivation bndr

+import GHC.Core.DataCon (dataConTyCon)

+

+import GHC.Core.Subst (substTickish)

+import GHC.Core.TyCon (tyConClass_maybe)

+import GHC.Core.Opt.Monad

+import GHC.Core.Opt.Simplify.Env ( SimplPhase(..), isActive )

+    is_active :: Activation -> Bool

+    is_active = isActive (SimplPhaseRange (beginPhase inl_act) (endPhase inl_act))

+{- Note [Demand on the worker]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+ruleCheckProgram ropts curr_phase rule_pat rules binds

+    is_active = isActiveInPhase curr_phase

+    env = RuleCheckEnv { rc_is_active = is_active

+                       , rc_id_unf    = whenActiveUnfoldingFun is_active

+import GHC.Core.Opt.Simplify.Env ( SimplMode(..), SimplPhase(..) )

+showLintWarnings (CoreDoSimplify cfg)

+  | SimplPhase InitialPhase <- sm_phase (so_mode cfg)

+  = False

+import GHC.Core.Opt.Simplify.Env ( FloatEnable(..), SimplMode(..), SimplPhase(..) )

+  , sm_phase = SimplPhase phase

+      aa_phase  :: SourceText,

+  noAnn = ActivationAnn noAnn NoSourceText noAnn noAnn noAnn

+repPhases (ActiveBefore i) = do { MkC arg <- coreIntLit i

+                                ; dataCon' beforePhaseDataConName [arg] }

+repPhases (ActiveAfter i)  = do { MkC arg <- coreIntLit i

+                                ; dataCon' fromPhaseDataConName [arg] }

+repPhases _                = dataCon allPhasesDataConName

+-- Rules can be specified to be never active, unlike inline/specialize pragmas

+        : '[' INTEGER ']'       { ( ActivationAnn (epTok $1) (getINTEGERs $2) (epTok $3) Nothing (Just (glR $2))

+                                  , ActiveAfter  (fromInteger (il_value (getINTEGER $2)))) }

+                                { ( ActivationAnn (epTok $1) (getINTEGERs $3) (epTok $4) $2 (Just (glR $3))

+                                  , ActiveBefore (fromInteger (il_value (getINTEGER $3)))) }

+                                { ( ActivationAnn (epTok $1) NoSourceText (epTok $3) $2 Nothing

+                                  , NeverActive ) }

+        : '[' INTEGER ']'       { (ActivationAnn (epTok $1) (getINTEGERs $2) (epTok  $3) Nothing (Just (glR $2))

+                                  ,ActiveAfter   (fromInteger (il_value (getINTEGER $2)))) }

+                                { (ActivationAnn (epTok $1) (getINTEGERs $3) (epTok $4) $2 (Just (glR $3))

+                                  ,ActiveBefore  (fromInteger (il_value (getINTEGER $3)))) }

+                     $ alwaysInlinePragma { inl_act = ActiveAfter 1 }

+cvtPhases (FromPhase i)   _    = ActiveAfter  i

+cvtPhases (BeforePhase i) _    = ActiveBefore i

+        CompilerPhase(..),

+        PhaseNum, nextPhase, laterPhase,

+        Activation(..), isActiveInPhase, competesWith,

+        beginPhase, endPhase, laterThanPhase,

+-- | Compilation phase number, as can be written by users in INLINE pragmas,

+-- SPECIALISE pragmas, and RULES.

+--

+--   - phases decrease towards zero

+--   - zero is the last phase

+--

+-- Does not include GHC internal "initial" and "final" phases; see 'CompilerPhase'.

+type PhaseNum = Int

+-- | Compilation phase number, including the user-specifiable 'PhaseNum'

+-- and the GHC internal "initial" and "final" phases.

+  = InitialPhase    -- ^ The first phase; number = infinity!

+  | Phase PhaseNum  -- ^ User-specifiable phases

+  | FinalPhase      -- ^ The last phase; number = -infinity!

+  deriving (Eq, Data)

+   ppr InitialPhase = text "initial"

+   ppr FinalPhase   = text "final"

+-- | An activation is a range of phases throughout which something is active

+-- (like an INLINE pragma, SPECIALISE pragma, or RULE).

+  -- | Active only *strictly before* this phase

+  | ActiveBefore PhaseNum

+  -- | Active in this phase and later phases

+  | ActiveAfter  PhaseNum

+  -- | Active in the final phase only

+  | FinalActive

+-- ^ First phase in which the 'Activation' is active,

+-- or 'FinalPhase' if it is never active

+beginPhase (ActiveAfter n)   = Phase n

+endPhase :: Activation -> CompilerPhase

+-- ^ Last phase in which the 'Activation' is active,

+-- or 'InitialPhase' if it is never active

+endPhase AlwaysActive       = FinalPhase

+endPhase (ActiveBefore n)   =

+  if nextPhase InitialPhase == Phase n

+  then InitialPhase

+  else Phase $ n + 1

+endPhase (ActiveAfter {})   = FinalPhase

+endPhase FinalActive        = FinalPhase

+endPhase NeverActive        = InitialPhase

+

+-- ^ @activeAfter p@ makes an 'Activation' that is active in phase @p@ and after

+--

+-- Invariant: @beginPhase (activeAfter p) = p@

+activeAfter (Phase n)    = ActiveAfter n

+-- ^ Tells you the next phase after this one

+--

+-- Currently we have just phases @[2,1,0,FinalPhase,FinalPhase,...]@,

+-- where FinalPhase means GHC's internal simplification steps

+-- ^ Returns the later of two phases

+-- | @p1 `laterThanOrEqualPhase` p2@ computes whether @p1@ happens (strictly)

+-- after @p2@.

+laterThanPhase :: CompilerPhase -> CompilerPhase -> Bool

+p1 `laterThanPhase` p2 = toNum p1 < toNum p2

+  where

+    toNum :: CompilerPhase -> Int

+    toNum InitialPhase = maxBound

+    toNum (Phase i)    = i

+    toNum FinalPhase   = minBound

+

+-- ^ Active in the first phase after the initial phase

+-- ^ Active in the final simplification phase (which is repeated)

+isActiveInPhase :: CompilerPhase -> Activation -> Bool

+isActiveInPhase InitialPhase act = activeInInitialPhase act

+isActiveInPhase (Phase p)    act = activeInPhase p act

+isActiveInPhase FinalPhase   act = activeInFinalPhase act

+activeInInitialPhase act = beginPhase act == InitialPhase