tidyEqnInfo _ eqn@(EqnDone {}) = return (idDsWrapper, eqn)

   return (wrap, eqn{eqn_pat = L loc pat' })

 tidy1 :: MatchId             -- The scrutinee

       -> Pat GhcTc           -- The pattern against which it is to be matched

       -> DsM (DsWrapper,     -- Extra bindings to do before the match

               Pat GhcTc)     -- Equivalent pattern

 -- It eliminates many pattern forms (as-patterns, variable patterns,

 -- list patterns, etc) and returns any created bindings in the wrapper.

         -- case v of { x -> mr[] }

         -- = case v of { _ -> let x=v in mr[] }

   = return (bindMatchId var v, WildPat (idType var))

         -- case v of { x@p -> mr[] }

         -- = case v of { p -> let x=v in mr[] }

         ; return (bindMatchId var v . wrap, pat') }

 {- now, here we handle lazy patterns:

     The case expr for v_i is just: match [v] [(p, [], \ x -> Var v_i)] any_expr

 -}

     -- This is a convenient place to check for unlifted types under a lazy pattern.

     -- Doing this check during type-checking is unsatisfactory because we may

     -- not fully know the zonked types yet. We sure do here.

         ; let sel_binds =  [NonRec b rhs | (b,rhs) <- sel_prs]

         ; return (mkCoreLets sel_binds, WildPat (matchIdType v)) }

   = return (idDsWrapper, unLoc list_ConPat)

   where

     list_ConPat = foldr (\ x y -> mkPrefixConPat consDataCon [x, y] [ty])

                         (mkNilPat ty)

                         pats

   = return (idDsWrapper, unLoc tuple_ConPat)

   where

     arity = length pats

              Boxed   -> tys

            -- See Note [Unboxed tuple RuntimeRep vars] in TyCon

   = return (idDsWrapper, unLoc sum_ConPat)

   where

     sum_ConPat = mkPrefixConPat (sumDataCon alt arity) [pat] (map getRuntimeRep tys ++ tys)

                  -- See Note [Unboxed tuple RuntimeRep vars] in TyCon

 -- LitPats: we *might* be able to replace these w/ a simpler form

            warnAboutOverflowedLit lit

        ; return (idDsWrapper, tidyLitPat lit) }

 -- NPats: we *might* be able to replace these w/ a simpler form

            let lit' | Just _ <- mb_neg = lit{ ol_val = negateOverLitVal v }

                     | otherwise = lit

            in warnAboutOverflowedOverLit lit'

        ; return (idDsWrapper, tidyNPat lit mb_neg eq ty) }

 -- NPlusKPat: we may want to warn about the literals

            warnAboutOverflowedOverLit lit1

            warnAboutOverflowedOverLit lit2

        ; return (idDsWrapper, n) }

   -- See Note [Implementation of OrPatterns]. We desugar

   --   (1; 2; 3)

   -- to

     single_grhs e = GRHSs emptyComments [noLocA $ GRHS noAnn [] e] (EmptyLocalBinds noExtField)

 -- Everything else goes through unchanged...

   = return (idDsWrapper, non_interesting_pat)

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

               -> DsM (DsWrapper, Pat GhcTc)

 -- Discard par/sig under a bang

 -- Push the bang-pattern inwards, in the hope that

 -- it may disappear next time

 -- Discard bang around strict pattern

 -- Data/newtype constructors

   -- Newtypes: push bang inwards (#9844)

   =

     if isNewTyCon (dataConTyCon dc)

     where

       (ty:_) = dataConInstArgTys dc arg_tys

 --

 -- NB: SigPatIn, ConPatIn should not happen

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

 push_bang_into_newtype_arg :: SrcSpanAnnA

        ; ldi_nablas <-

          if  isMatchContextPmChecked_SinglePat dflags FromSource ctx pat

          then addCoreScrutTmCs (maybeToList mb_scrut) [var] $

          else getLdiNablas

        ; let eqn_info = EqnMatch { eqn_pat = decideBangHood dflags pat

 import GHC.Hs

 import GHC.Tc.Utils.TcMType ( shortCutLit )

 import GHC.Tc.Utils.TcType

     mk_con_pat :: DataCon -> HsLit GhcTc -> Pat GhcTc

     mk_con_pat con lit

     mb_int_lit :: Maybe Integer

     mb_int_lit = case (mb_neg, val) of

         duplicateLocalDs, newSysLocalDs, newSysLocalsDs,

         newSysLocalMDs, newSysLocalsMDs, newFailLocalMDs,

         newUniqueId, newPredVarDs, newStaticId,

         mkNamePprCtxDs,

         newUnique,

         UniqSupply, newUniqueSupply,

                            , dsl_loc         = real_span

                            , dsl_nablas      = Ldi initNablas

                            , dsl_unspecables = Just emptyVarSet

                            }

     in (gbl_env, lcl_env)

 getSrcSpanDs = do { env <- getLclEnv

                   ; return (RealSrcSpan (dsl_loc env) Strict.Nothing) }

 putSrcSpanDs :: SrcSpan -> DsM a -> DsM a

 putSrcSpanDs (RealSrcSpan real_span _) thing_inside

 putSrcSpanDs UnhelpfulSpan{} thing_inside

   = thing_inside

 putSrcSpanDs GeneratedSrcSpan{} thing_inside

 putSrcSpanDsA :: EpAnn ann -> DsM a -> DsM a

 putSrcSpanDsA loc = putSrcSpanDs (locA loc)

             Ldi nablas -> thing_inside nablas }

 -- | Check a pattern binding (let, where) for exhaustiveness.

 pmcPatBind ctxt@(DsMatchContext match_ctxt loc) var p

   = whenDoingPmc NoPmc $ \ !missing ->

     mb_discard_warnings $ do

   VarPat _ y   -> pure (mkPmLetVar (unLoc y) x)

   ParPat _ p   -> desugarLPat x p

   LazyPat _ _  -> pure GdEnd -- like a wildcard

     -- Add the bang in front of the list, because it will happen before any

     -- nested stuff.

     consGrdDag (PmBang x pm_loc) <$> desugarLPat x p

   -- (x@pat)   ==>   Desugar pat with x as match var and handle impedance

   --                 mismatch with incoming match var

   pure (x, grds)

 desugarLPat :: Id -> LPat GhcTc -> DsM GrdDag

 -- | 'desugarLPat', but also select and return a new match var.

 desugarLPatV :: LPat GhcTc -> DsM (Id, GrdDag)

 -- | @desugarListPat _ x [p1, ..., pn]@ is basically

 --   @desugarConPatOut _ x $(mkListConPatOuts [p1, ..., pn]>@ without ever

       -- tracePm "ConPatOut" (ppr x $$ ppr con $$ ppr arg_ids)

       pure (con_grd `consGrdDag` arg_grds)

 -- See 'GrdPatBind' for how this simply repurposes GrdGRHS.

 -- See Note [Suppress warnings in PMC desugaring]

 desugarPatBind loc var pat = discardWarningsDs $

 desugarEmptyCase :: Id -> DsM PmEmptyCase

 desugarEmptyCase var = pure PmEmptyCase { pe_var = var }

   idV :: Void -> Void

   idV v = v

 -}

         DsMetaEnv, DsMetaVal(..), CompleteMatches

     ) where

 import Data.IORef

   -- ^ See Note [Desugaring non-canonical evidence]

   -- This field collects all un-specialisable evidence variables in scope.

   -- Nothing <=> don't collect this info (used for the LHS of Rules)

   }

 -- Inside [| |] brackets, the desugarer looks

 import GHC.Builtin.KnownKeys

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import GHC.Types.SrcLoc

 import GHC.Types.Tickish

 import GHC.Utils.Misc

 -}

 decideBangHood :: DynFlags

                -> LPat GhcTc  -- ^ Original pattern

                -> LPat GhcTc  -- Pattern with bang if necessary

            ParPat x p -> L l (ParPat x (go p))

            LazyPat _ lp' -> lp'

            BangPat _ _   -> lp

 isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)

 test('T22652', [], compile, [overlapping_incomplete])

 test('T22652a', [], compile, [overlapping_incomplete])

 test('T24867', [], compile_fail, [overlapping_incomplete])

 test('T27360', normal, compile, [overlapping_incomplete + '-g3'])

 Overflow.hs:8:15: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal 10000000000000000000000000000000 is out of the Int# range -2147483648..2147483647

     Literal 100000000000000000000000000 is out of the Int# range -2147483648..2147483647

 Overflow.hs:18:5: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal 1000000000000000000000000000000 is out of the Int range -2147483648..2147483647

     Literal 100000000000000000000000000000000 is out of the Int range -2147483648..2147483647

 Overflow.hs:27:6: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal -1 is out of the Word range 0..4294967295

     Literal -1 is out of the Word range 0..4294967295

 Overflow.hs:8:15: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal 10000000000000000000000000000000 is out of the Int# range -9223372036854775808..9223372036854775807

     Literal 100000000000000000000000000 is out of the Int# range -9223372036854775808..9223372036854775807

 Overflow.hs:18:5: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal 1000000000000000000000000000000 is out of the Int range -9223372036854775808..9223372036854775807

     Literal 100000000000000000000000000000000 is out of the Int range -9223372036854775808..9223372036854775807

 Overflow.hs:27:6: warning: [GHC-97441] [-Woverflowed-literals (in -Wdefault)]

     Literal -1 is out of the Word range 0..18446744073709551615

     Literal -1 is out of the Word range 0..18446744073709551615

     Literal 100000000000000000000000000000000 is out of the Int range -2147483648..2147483647

     Literal 100000000000000000000000000000000 is out of the Int range -9223372036854775808..9223372036854775807