{-

 (c) The University of Glasgow 2006

 (c) The AQUA Project, Glasgow University, 1994-1998

 import GHC.Utils.Misc

 import GHC.Utils.Outputable

 import qualified Data.ByteString as BS

 import Data.List.NonEmpty (nonEmpty)

          -> [Id]            -- Arguments; we're interested in which of these

                             -- get case'd

          -> CoreExpr

 -- Note [Computing the size of an expression]

 sizeExpr opts !bOMB_OUT_SIZE top_args expr

   = size_up sizeZero expr

   where

     size_up TooBig !_ = TooBig

     size_up s (Cast e _)  = size_up s e

     size_up s (Tick _ e)  = size_up s e

                         -- Make sure we get constructor discounts even

                         -- on nullary constructors

                         | otherwise       = size_up_call s f [] 0

     size_up s (Let (Rec pairs) body)

                 body

     size_up s (Case e _ _ alts) = case nonEmpty alts of

                 -- And it eliminates the case itself

         | otherwise -> foldr  (addAltSize . size_up_alt s)

                               alts

         where

               | otherwise

                 = False

     size_up_let s (bndr, rhs)

       | JoinPoint join_arity <- idJoinPointHood bndr

         -- Skip arguments to join point

       | otherwise

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

     -- size_up_app is used when there's ONE OR MORE value args

     size_up_app s (App fun arg) args voids

         | isTyCoArg arg                  = size_up_app s fun args voids

         | isZeroBitExpr arg              = size_up_app s fun (arg:args) (voids + 1)

        -- size of the lhs itself.

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

     size_up_call !s fun val_args voids

        = let !n_args = length val_args

              call_size = case idDetails fun of

                             DataConWorkId dc              -> conSize    dc n_args

                             _ | fun `hasKey` buildIdKey   -> buildSize

                               | fun `hasKey` augmentIdKey -> augmentSize

                               | otherwise                 -> funSize opts top_args fun n_args voids

         size_up (sizeN s) rhs

                 -- Why add and then subtract s?

                 -- If the expression large enough this will ensure we bomb out early.

         -- Don't charge for args, so that wrappers look cheap

         -- (See comments about wrappers with Case)

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

         -- These addSize things have to be here because

         -- I don't want to give them bOMB_OUT_SIZE as an argument

     addSizeN TooBig          _  = TooBig

         -- addAltSize is used to add the sizes of case alternatives

     addAltSize TooBig            _      = TooBig

     addAltSize _                 TooBig = TooBig

     addAltSize (SizeIs n1 xs d1) (SizeIs n2 ys d2)

                                  (xs `unionBags` ys)

                                  (d1 + d2) -- Note [addAltSize result discounts]

         -- This variant ignores the result discount from its LEFT argument

         -- It's used when the second argument isn't part of the result

     addSizeNSD TooBig            _      = TooBig

     addSizeNSD _                 TooBig = TooBig

     addSizeNSD (SizeIs n1 xs _) (SizeIs n2 ys d2)

                                  (xs `unionBags` ys)

                                  d2  -- Ignore d1

     -- this benefit for the body.

     -- Why? `x` is visible to `body` either way, so it really should not

     -- affect our inlining decision either way.

     stripDiscounts TooBig = TooBig

     stripDiscounts (SizeIs n xs _) = (SizeIs n xs 0)

                       -- Key point: if  x |-> 4, then x must inline unconditionally

                       --            (eg via case binding)

 -- See Note [Conlike is interesting]

 classOpSize opts cls top_args args

   | isUnaryClass cls

   -- spectral/puzzle. TODO Perhaps adjusting the default threshold would be a

   -- better solution?

 -- Size for function calls where the function is not a constructor or primops

 -- Note [Function applications]

 funSize opts top_args fun n_val_args voids

         -- If the function is partially applied, show a result discount

 -- XXX maybe behave like ConSize for eval'd variable

 conSize dc n_val_args

   | n_val_args == 0 = SizeIs 0 emptyBag 10    -- Like variables

 -- See Note [Unboxed tuple size and result discount]

   | isUnboxedTupleDataCon dc = SizeIs 0 emptyBag 10

 -- See Note [Constructor size and result discount]

   | otherwise = SizeIs 10 emptyBag 10

 all those constants to top level.

 -}

 primOpSize op n_val_args

  = if primOpOutOfLine op

       then sizeN (op_size + n_val_args)

    op_size = primOpCodeSize op

 buildSize = SizeIs 0 emptyBag 40

         -- We really want to inline applications of build

         -- build t (\cn -> e) should cost only the cost of e (because build will be inlined later)

         -- build is saturated (it usually is).  The "-2" discounts for the \c n,

         -- The "4" is rather arbitrary.

 augmentSize = SizeIs 0 emptyBag 40

         -- Ditto (augment t (\cn -> e) ys) should cost only the cost of

         -- e plus ys. The -2 accounts for the \cn

 -- When we return a lambda, give a discount if it's used (applied)

 lamScrutDiscount opts (SizeIs n vs _) = SizeIs n vs (unfoldingFunAppDiscount opts)

 lamScrutDiscount _      TooBig          = TooBig

 Code for manipulating sizes

 -}

 -- | The size of a candidate expression for unfolding

     = TooBig

     | SizeIs { _es_size_is  :: {-# UNPACK #-} !Int -- ^ Size found

              , _es_args     :: !(Bag (Id,Int))

                -- ^ Arguments cased herein, and discount for each such

              , _es_discount :: {-# UNPACK #-} !Int

                -- ^ Size to subtract if result is scrutinised by a case

              }

   ppr TooBig         = text "TooBig"

   ppr (SizeIs a _ c) = brackets (int a <+> int c)

 --      tup = (a_1, ..., a_99)

 --      x = case tup of ...

 --

 maxSize TooBig         _                                  = TooBig

 maxSize _              TooBig                             = TooBig

 maxSize s1@(SizeIs n1 _ _) s2@(SizeIs n2 _ _) | n1 > n2   = s1

                                               | otherwise = s2

 sizeZero = SizeIs 0 emptyBag 0

 sizeN n  = SizeIs n emptyBag 0