{ lpr_diagOpts         :: !DiagOpts

   , lpr_platform         :: !Platform

   , lpr_makeLintFlags    :: !LintFlags

   , lpr_passPpr          :: !SDoc

   , lpr_localsInScope    :: ![Var]

   }

            "Core Linted result of " ++

            renderWithContext defaultSDocContext (lpr_passPpr cfg)

        ; displayLintResults logger

                             (pprCoreBindings binds) warns_and_errs

        }

 displayLintResults :: Logger

                    -> SDoc -- ^ The source of the linted program

                    -> SDoc -- ^ The linted program, pretty-printed

                    -> WarnsAndErrs

                    -> IO ()

   | not (isEmptyBag errs)

   = do { lintMessage logger

            (vcat [ lint_banner "errors" pp_what, Err.pprMessageBag errs

   | not (isEmptyBag warns)

   , log_enable_debug (logFlags logger)

   = lintMessage logger

         (lint_banner "warnings" pp_what $$ Err.pprMessageBag (mapBag ($$ blankLine) warns))

 So Lint current accepts (Coercion co) in arbitrary places.  There is no harm in

 that: it really is a value, albeit a zero-bit value.

 ************************************************************************

 *                                                                      *

 \subsection[lintCoreExpr]{lintCoreExpr}

        ; return var_pair }

 lintCoreExpr (Lit lit)

 lintCoreExpr (Cast expr co)

   = do { (expr_ty, ue) <- markAllJoinsBad (lintCoreExpr expr)

            -> [CoAxiom Branched]

            -> IO ()

 lintAxioms logger cfg what axioms =

   initL cfg $

   do { mapM_ lint_axiom axioms

      ; let axiom_groups = groupWith coAxiomTyCon axioms

   = LF { lf_check_global_ids           :: Bool -- See Note [Checking for global Ids]

        , lf_check_inline_loop_breakers :: Bool -- See Note [Checking for INLINE loop breakers]

        , lf_check_static_ptrs :: StaticPtrCheck -- ^ See Note [Checking StaticPtrs]

     }

 -- See Note [Checking StaticPtrs]

 -- Suppose @f x@ diverges; then @C (f x)@ is not a value.

 -- We check for this using needsCaseBinding below

 exprIsHNF :: CoreExpr -> Bool           -- True => Value-lambda, constructor, PAP

 -- | Similar to 'exprIsHNF' but includes CONLIKE functions as well as

 -- data constructors. Conlike arguments are considered interesting by the

 -- inliner.

 exprIsConLike :: CoreExpr -> Bool       -- True => lambda, conlike, PAP

 -- | Returns true for values or value-like expressions. These are lambdas,

 -- constructors / CONLIKE functions (as determined by the function argument)

 -- or PAPs.

 --

   = -- pprTraceWith "hnf" (\r -> ppr r <+> ppr e) $

     is_hnf_like e

   where

       || definitelyUnliftedType (idType v)

         -- Unlifted binders are always evaluated (#20140)

         -- Regarding a LitRubbish as ConLike leads to unproductive inlining in

         -- WWRec, see #20035

     is_hnf_like (Type _)         = True       -- Types are honorary Values;

                                               -- we don't mind copying them

     is_hnf_like (Coercion _)     = True       -- Same for coercions

           | otherwise

           = Nothing

 {-

 Note [exprIsHNF Tick]

   { lpr_diagOpts      = initDiagOpts dflags

   , lpr_platform      = targetPlatform dflags

   , lpr_makeLintFlags = perPassFlags dflags pass

   , lpr_passPpr = ppr pass

   , lpr_localsInScope = extra_vars

   }

 perPassFlags :: DynFlags -> CoreToDo -> LintFlags

 perPassFlags dflags pass

   = (defaultLintFlags dflags)

                , lf_check_inline_loop_breakers = check_lbs

   where

     -- See Note [Checking for global Ids]

     check_globals = case pass of

     check_lbs = case pass of

                       CoreDesugar    -> False

                       CoreDesugarOpt -> False

                       _              -> True

     -- See Note [Checking StaticPtrs]

                           CoreDesugar -> True

                           _ -> False)

 initLintConfig :: DynFlags -> [Var] -> LintConfig

 initLintConfig dflags vars =LintConfig

   { l_diagOpts = initDiagOpts dflags

                              , lf_check_linearity = gopt Opt_DoLinearCoreLinting dflags

                              , lf_report_unsat_syns = True

                              , lf_check_fixed_rep = True

                              }

 import GHC.Core

 import GHC.Core.Ppr

 import GHC.Core.Lint

 import GHC.Core.Lint.Interactive

 import GHC.Data.Bag

 import GHC.Utils.Outputable as Outputable

   | not (gopt Opt_DoCoreLinting dflags)

   = return ()

   | Just err <- lintExpr (initLintConfig dflags $ interactiveInScope $ hsc_IC hsc_env) expr

   | otherwise

   = return ()

   where

       IfaceClass{ifBody = IfConcreteClass { ifSigs=sigs, ifATs=ats }} ->

                      IfaceClassExtras (fix_fn n) insts (ann_fn (AnnOccName n)) meths defms

           where

             meths = [id_extras (getOccName op) | IfaceClassOp op _ _ <- sigs]

             -- Names of all the default methods (see Note [default method Name])

             defms = [ dmName

   where

         n = getOccName decl

         id_extras occ = IdExtras (fix_fn occ) (lookupOccEnvL rule_env occ) (ann_fn (AnnOccName occ)) (lookup_complete_match occ)

         lookup_complete_match occ = lookupOccEnvL complete_env occ

                           Nothing   -> return ()

                           Just errs -> do

                             logger <- getLogger

                                                (pprCoreExpr rhs')

                                                (emptyBag, errs) }

                    ; return (bndrs', args', rhs') }

         case lintUnfolding is_compulsory (initLintConfig dflags in_scope) noSrcLoc core_expr' of

           Nothing   -> return ()

           Just errs -> liftIO $

                                (pprCoreExpr core_expr') (emptyBag, errs)

     return core_expr'

   where

 import random

 test('arith001', normal, compile_and_run, [''])

 test('arith002', normal, compile_and_run, [''])

 test('arith003', normal, compile_and_run, [''])