That is the whole reason for computing rule_fv_env in mkLoopBreakerNodes.

 Wrinkles:

   group.  See also Note [Finding rule RHS free vars]

   contrast to the way we build the Rec group in the first place (Note

   [Rule dependency info])

   unconditionally, without checking loop-breaker-ness.

  See Note [Loop breaker dependencies].

     add_rule_uds (_, l, r) uds = l `andUDs` r `andUDs` uds

     -------- active_rule_fvs ------------

     active_rule_fvs = foldr add_active_rule imp_rule_fvs rules_w_uds

     add_active_rule (rule, _, rhs_uds) fvs

       = udFreeVars bndr_set rhs_uds `unionVarSet` fvs

       | otherwise

       = fvs

         -- * Environments

         SimplEnv(..), pprSimplEnv,   -- Temp not abstract

         seArityOpts, seCaseCase, seCaseFolding, seCaseMerge, seCastSwizzle,

         seDoEtaReduction, seEtaExpand, seFloatEnable, seInline, seNames,

         seOptCoercionOpts, sePhase, sePlatform, sePreInline,

 -- | 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.

   --

   --

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

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

   deriving Eq

 instance Outputable SimplPhase where

   ppr (SimplPhase p) = ppr p

   ppr (SimplPhaseRange s e) = brackets $ ppr s <> ellipsis <> ppr e

 --

 -- See Note [SimplPhase].

 isActive :: SimplPhase -> ActivationGhc -> Bool

 {- Note [SimplPhase]

 ~~~~~~~~~~~~~~~~~~~~

 -- See Note [Simplifying inside stable unfoldings]

 updModeForStableUnfoldings unf_act current_mode

   = current_mode

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

     , sm_eta_expand = False

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

 updModeForRuleRHS rule_act current_mode =

   current_mode

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

     , sm_eta_expand = False

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

     }

 --

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

   -> ActivationGhc -- ^ the activation of the RULE or stable unfolding

   -> SimplPhase

   | otherwise

   where

 {- Note [Simplifying rules]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

   -------------------------------------------------------------

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

   -------------------------------------------------------------

 This plan is implemented by:

   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.

 You might wonder about a situation such as the following:

   module M1 where

 **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.

 Note [Simplifying inside stable unfoldings]

   where

     srcTxt = SourceText $ fsLit "{-# INLINE"

     -- See Note [Wrapper activation]

           -- to inline no earlier than phase 2.  I got regressions in

           -- 'mate', due to changes in full laziness due to Note [Case

           -- MFEs], when I did earlier inlining.

 type instance XHsChar       (GhcPass _) = SourceText

 type instance XHsCharPrim   (GhcPass _) = SourceText

 type instance XHsString     (GhcPass _) = SourceText

 type instance XHsStringPrim (GhcPass _) = SourceText

 type instance XHsInt        (GhcPass _) = NoExtField

 type instance XHsIntPrim    (GhcPass _) = SourceText

     go (HsChar {})        = False

     go (HsCharPrim {})    = False

     go (HsString {})      = False

     go (HsStringPrim {})  = False

     go (HsInt _ x)        = p > topPrec && il_neg x

     go (HsFloatPrim {})   = False

 convertLit (HsChar a x)       = HsChar a x

 convertLit (HsCharPrim a x)   = HsCharPrim a x

 convertLit (HsString a x)     = HsString a x

 convertLit (HsStringPrim a x) = HsStringPrim a x

 convertLit (HsInt a x)        = HsInt a x

 convertLit (HsIntPrim a x)    = HsIntPrim a x

 instance IsPass p => Outputable (HsLit (GhcPass p)) where

     ppr (HsChar st c)       = pprWithSourceText st (pprHsChar c)

     ppr (HsCharPrim st c)   = pprWithSourceText st (pprPrimChar c)

       case st of

         NoSourceText -> pprHsString s

         SourceText src -> vcat $ map text $ split '\n' (unpackFS src)

   ppr (HsFractional f)   = ppr f

   ppr (HsIsString st s)  = pprWithSourceText st (pprHsString s)

 negateOverLitVal :: OverLitVal -> OverLitVal

 negateOverLitVal (HsIntegral i) = HsIntegral (negateIntegralLit i)

 negateOverLitVal (HsFractional f) = HsFractional (negateFractionalLit f)

 hsLitType (HsChar _ _)       = charTy

 hsLitType (HsCharPrim _ _)   = charPrimTy

 hsLitType (HsString _ _)     = stringTy

 hsLitType (HsStringPrim _ _) = addrPrimTy

 hsLitType (HsInt _ _)        = intTy

 hsLitType (HsIntPrim _ _)    = intPrimTy

     HsDoublePrim _ fl -> return (Lit (LitDouble (rationalFromFractionalLit fl)))

     HsChar _ c       -> return (mkCharExpr c)

     HsString _ str   -> mkStringExprFS str

     HsInt _ i        -> return (mkIntExpr platform (il_value i))

     XLit x           -> case ghcPass @p of

       GhcTc          -> case x of

 getSimpleIntegralLit HsChar{}           = Nothing

 getSimpleIntegralLit HsCharPrim{}       = Nothing

 getSimpleIntegralLit HsString{}         = Nothing

 getSimpleIntegralLit HsStringPrim{}     = Nothing

 getSimpleIntegralLit (XLit (HsRat{}))   = Nothing

 getSimpleIntegralLit HsFloatPrim{}      = Nothing

                  HsChar _ _       -> Just charLName

                  HsCharPrim _ _   -> Just charPrimLName

                  HsString _ _     -> Just stringLName

                  _                -> Nothing

 mk_integer :: Integer -> MetaM (HsLit GhcTc)

         : CHAR              { sL1 $1 $ HsChar       (getCHARs $1) $ getCHAR $1 }

         | STRING            { sL1 $1 $ HsString     (getSTRINGs $1)

                                                     $ getSTRING $1 }

                                                     $ getSTRINGMULTI $1 }

         | PRIMINTEGER       { sL1 $1 $ HsIntPrim    (getPRIMINTEGERs $1)

                                                     $ getPRIMINTEGER $1 }

 Multiline string literals are syntax sugar for normal string literals,

 with an extra post processing step. This all happens in the Lexer; that

 The canonical steps for post processing a multiline string are:

 1. Collapse string gaps

     hs_ty_arg = mkEmptyWildCardBndrs $ wrapGenSpan $

                 HsTyLit noExtField (HsStrTy NoSourceText v)

   = do { opt_OverloadedStrings <- xoptM LangExt.OverloadedStrings

        ; if opt_OverloadedStrings then

             rnExpr (HsOverLit x (mkHsIsString src s))

          else do {

             ; rnLit lit

             ; return (HsLit x (convertLit lit), emptyFVs) } }

 rnExpr (HsLit x lit)

   = do { rnLit lit

 tyLitFromLit :: HsLit GhcRn -> Maybe (HsTyLit GhcRn)

 tyLitFromLit (HsString x str) = Just (HsStrTy x str)

 tyLitFromLit (HsChar x char) = Just (HsCharTy x char)

 tyLitFromLit _ = Nothing

   , endPhase

     -- *** Queries

   , isActiveInPhase

   ) where

 import GHC.Prelude

 nextPhase (Phase n)    = Phase (n-1)

 nextPhase FinalPhase   = FinalPhase

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

 -- after @p2@.

 type family XHsChar x

 type family XHsCharPrim x

 type family XHsString x

 type family XHsStringPrim x

 type family XHsInt x

 type family XHsIntPrim x

       -- ^ Unboxed character

   | HsString (XHsString x) {- SourceText -} FastString

       -- ^ String

   | HsStringPrim (XHsStringPrim x) {- SourceText -} !ByteString

       -- ^ Packed bytes

   | HsInt (XHsInt x)  IntegralLit

     Allow the use of multi-way-``if`` syntax.

 multiple branches: ::

       if | guard1 -> expr1

         ...

         _ | guardN -> exprN

 above is equivalent to: ::

       if { | guard1 -> expr1

          }

 The following behaves as expected: ::

 because layout translates it as ::

       if { | guard1 -> if { | guard2 -> expr2

                           }

          }

 Layout with multi-way if works in the same way as other layout contexts,

 column; this is consistent with the way guards work in function

 definitions and case expressions.

 -- * Compile or preprocess a source file.

 -- * Extract source dependencies by passing @-MM@ command line argument.

 data CcMode = CompileC | FindCDependencies DependencyType deriving (Eq, Generic, Show)

 instance Binary   CcMode

 instance Hashable CcMode

             discover   -- Continue the discovery process

     -- We need to pass different flags to cc depending on whether the

     parseFile :: FilePath -> Action [String]

     parseFile file = do

             , arg "-o", arg =<< getOutput ]

         , builder (Cc (FindCDependencies CDep)) ? findCDepExpr CDep

         , builder (Cc (FindCDependencies CxxDep)) ? findCDepExpr CxxDep

         ]

     where

         findCDepExpr depType = do

                     , arg "-MM", arg "-MG"

                     , arg "-MF", arg output

                     , arg "-MT", arg $ dropExtension output -<.> "o"

                     , cIncludeArgs

                     -- Pass 'ghcversion.h' to give sources access to the

                     -- `MIN_VERSION_GLASGOW_HASKELL` macro.

                     , notStage0 ? arg "-include" <> arg "rts/include/ghcversion.h"

               ]

         , builder (Cc (FindCDependencies CDep)) ? cArgs

         , builder (Cc (FindCDependencies  CxxDep)) ? cArgs

         , builder (Ghc CompileCWithGhc) ? map ("-optc" ++) <$> cArgs

         , builder (Ghc CompileCppWithGhc) ? map ("-optcxx" ++) <$> cArgs

         , builder Ghc ? ghcArgs

 test('T26418', normal, compile_fail, [''])

 test('T12488c', normal, compile_fail, [''])

 test('T12488d', normal, compile_fail, [''])

 # T26722: there should be no reboxing in $wg

 test('T26722', [grep_errmsg(r'SPEC')], compile, ['-O -dno-typeable-binds'])

 test('T26805', [grep_errmsg(r'fromInteger')], compile, ['-O -dno-typeable-binds -ddump-simpl -dsuppress-uniques'])

     HsChar       src v   -> toSourceTextWithSuffix src v ""

     HsCharPrim   src p   -> toSourceTextWithSuffix src p ""

     HsString     src v   -> toSourceTextWithSuffix src v ""

     HsStringPrim src v   -> toSourceTextWithSuffix src v ""

     HsInt        _ (IL src _ v)   -> toSourceTextWithSuffix src v ""

     HsIntPrim    src v   -> toSourceTextWithSuffix src v ""