+             in f vs }

+           case y of { I# w ->

+             in f vs }}

+  |  notWorthFloating expr abs_vars

+  || not float_me

+                           -- esp Bottoming floats (BF2)

+               -- NB: is_bot_lam not is_bot; see (BF2) in Note [Bottoming floats]

+        -- Never float trivial expressions;

+        --   notably, save_work might be true of a lone evaluated variable.

+    is_hnf = exprIsHNF expr

+                 && not is_hnf            -- (b)

+    -- See Note [Floating to the top]

+    saves_alloc = isTopLvl dest_lvl

+               && (  (floatConsts env &&

+                       (not strict_ctxt || is_hnf))     -- (FT1) and (FT2)

+                  || (is_bot_lam && escapes_value_lam)) -- (FT3)

+But see also Note [Floating to the top].

+Note [Floating to the top]

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

+expressions out of value lambdas. Data suggests, however, that it is better

+/only/ to do so, /if/ they can go to top level. If the expression goes to top

+level we don't pay the cost of allocating cold-path thunks described in (SW2).

+* In principle this would be true even if the (\y.e) didn't go to top level; but

+  in practice we only float a HNF if it goes all way to the top.  We don't pay

+  /any/ allocation cost for a top-level floated expression; it just becomes

+  static data.

+

+* Floating string literals is valuable -- no point in duplicating the

+  (FT1) the context is lazy (so we get allocation), or

+  (FT2) the expression is a HNF (so we get allocation), or

+  (FT3) the expression is bottoming and floating would escape a

+         value lambda (NB: if the expression itself is a lambda, (b)

+         will apply; so this case only catches bottoming thunks)

+* (FT1) Strict.  Case scrutinee

+* (FT1) Strict.  Case alternative

+* (FT2) HNF

+* (FT3) Bottoming expressions; see also Note [Bottoming floats]

+* (FT4) Arguments

+(BF1) We want to float a bottoming

+    To achieve this we pass `is_bot` to destLevel

+

+(BF2) We do the same for /lambdas/ that return bottom.

+    Suppose the original lambda had /no/ free vars:

+        f = \x. ....(\y z. error (y++z))...

+    then we'd like to float that whole lambda

+        lvl = \y z. error (y++z)

+        f = \x. ....lvl....

+    If we just floated its bottom-valued body, we might abstract the arguments in

+    the "wrong" order and end up with this bad result

+        lvl = \z y. error (y++z)

+        f = \x. ....(\y z. lvl z y)....

+

+    If the lambda does have free vars, this will happen:

+    We float the whole lambda thus

+    And we may well end up eta-expanding that PAP to

+        lvl = \x. \y z. if b then error y else error z

+    so we get a (small) closure.  So be it.

+(BF3) If we have a /binding/ that returns bottom, we want to float it to top

+--  See Note [notWorthFloating]

+  = go e 0

+    n_abs_vars = count isId abs_vars  -- See (NWF5)

+

+    go :: CoreExpr -> Int -> Bool

+    -- (go e n) return True if (e x1 .. xn) is not worth floating

+    -- where `e` has n trivial value arguments x1..xn

+    -- See (NWF4)

+    go (Lit lit) n         = assert (n==0) $

+                             litIsTrivial lit   -- See (NWF1)

+    go (Type {}) _         = True

+    go (Tick t e) n        = not (tickishIsCode t) && go e n

+    go (Cast e _) n        = n==0 || go e n     -- See (NWF3)

+    go (Coercion {}) _     = True

+       | Type {} <- arg    = go e n    -- Just types, not coercions (NWF2)

+       | exprIsTrivial arg = go e (n+1)

+       | otherwise         = False  -- (f non-triv) is worth floating

+

+    go (Case e b _ as) _

+      -- Do not float the `case` part of trivial cases (NWF3)

+      -- We'll have a look at the RHS when we get there

+      = True   -- See Note [Empty case is trivial]

+      | Just {} <- isUnsafeEqualityCase e b as

+      = True   -- See (U2) of Note [Implementing unsafeCoerce] in base:Unsafe.Coerce

+      | otherwise

+      = False

+    go (Var _) n

+      | n==0             = True   -- Naked variable

+      | n <= n_abs_vars  = True   -- (f a b c) is not worth floating if

+      | otherwise        = False  -- a,b,c are all abstracted; see (NWF5)

+    go _ _ = False  -- Let etc is worth floating

+{- Note [notWorthFloating]

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

+`notWorthFloating` returns True if the expression would be replaced by something

+bigger than it is now.  One big goal is that floating should be idempotent.  Eg

+if we replace e with (lvl79 x y) and then run FloatOut again, don't want to

+replace (lvl79 x y) with (lvl83 x y)!

+For example:

+  abs_vars = tvars only:  return True if e is trivial,

+                          but False for anything bigger

+  abs_vars = [x] (an Id): return True for trivial, or an application (f x)

+                          but False for (f x x)

+

+(NWF1) It's important to float Integer literals, so that they get shared, rather

+  than being allocated every time round the loop.  Hence the litIsTrivial.

+

+  Ditto literal strings (LitString), which we'd like to float to top

+  level, which is now possible.

+

+(NWF2) We don’t float out variables applied only to type arguments, since the

+  extra binding would be pointless: type arguments are completely erased.

+  But *coercion* arguments aren’t (see Note [Coercion tokens] in

+  "GHC.CoreToStg" and Note [inlineBoringOk] in"GHC.Core.Unfold"),

+  so we still want to float out variables applied only to

+  coercion arguments.

+

+(NWF3) Some expressions have trivial wrappers:

+     - Casts (e |> co)

+     - Unary-class applications:

+          - Dictionary applications (MkC meth)

+          - Class-op applictions    (op dict)

+     - Case of empty alts

+     - Unsafe-equality case

+  In all these cases we say "not worth floating", and we do so /regardless/

+  of the wrapped expression.  The SetLevels stuff may subsequently float the

+  components of the expression.

+

+  Example:  is it worth floating (f x |> co)?  No!  If we did we'd get

+     lvl = f x |> co

+     ...lvl....

+  Then we'd do cast worker/wrapper and end up with.

+     lvl' = f x

+     ...(lvl' |> co)...

+  Silly!  Better not to float it in the first place.  If we say "no" here,

+  we'll subsequently say "yes" for (f x) and get

+     lvl = f x

+     ....(lvl |> co)...

+  which is what we want.  In short: don't float trivial wrappers.

+

+(NWF4) The only non-trivial expression that we say "not worth floating" for

+  is an application

+             f x y z

+  where the number of value arguments is <= the number of abstracted Ids.

+  This is what makes floating idempotent.  Hence counting the number of

+  value arguments in `go`

+

+(NWF5) In #24471 we had something like

+     x1 = I# 1

+     ...

+     x1000 = I# 1000

+     foo = f x1 (f x2 (f x3 ....))

+  So every sub-expression in `foo` has lots and lots of free variables.  But

+  none of these sub-expressions float anywhere; the entire float-out pass is a

+  no-op.

+  So `notWorthFloating` tries to avoid evaluating `n_abs_vars`, in cases where

+  it obviously /is/ worth floating.  (In #24471 it turned out that we were

+  testing `abs_vars` (a relatively complicated calculation that takes at least

+  O(n-free-vars) time to compute) for every sub-expression.)

+  Hence testing `n_abs_vars only` at the very end.

+{- *********************************************************************

+*                                                                      *

+                       Bindings

+        This binding stuff works for top level too.

+*                                                                      *

+********************************************************************* -}

+

+        -- See Note [Bottoming floats] (BF3)

+  | is_bot              -- Send bottoming bindings to the top regardless;

+  = as_far_as_poss      -- see (BF1) and (BF2) in Note [Bottoming floats]

+    -- as_far_as_poss: destination level depends only on the free Ids (more

+    -- precisely, free CoVars) of the /type/, not the free Ids of the /term/.

+    -- Why worry about the free CoVars?  See Note [Floating and kind casts]

+    --

+    -- There may be free Ids in the term, but then we'll just

+    -- lambda-abstract over them

+-- Precisely the same as `maxFvLevel` but for TyCoVarSet rather than DVarSet

+  = return (emptyLetFloats, expr)         -- See Note [Cannot trivialise]

+  | otherwise