.lint:

   stage: tool-lint

   tags:

   rules:

     - *drafts-can-fail-lint

     - when: always

 .nightly: &nightly

   variables:

     XZ_OPT: "-9"

   stage: not-interruptible

   script: "true"

   interruptible: false

   variables:

     GIT_STRATEGY: none

   tags:

   rules:

 #   - if: '$CI_COMMIT_BRANCH == "master"'

 #      when: always

 ghc-linters:

   stage: tool-lint

   extends: .lint-params

   variables:

     BUILD_FLAVOUR: default

 # Skipped if the MR has the ~"no-changelog" label.

 lint-changelog:

   stage: tool-lint

   variables:

     CHANGELOG_EXPECT_MR: "$CI_MERGE_REQUEST_IID"

     GIT_DEPTH: 1

     GIT_SUBMODULE_STRATEGY: none

   script:

     - .gitlab/ci.sh lint_changelog

   dependencies: []

 # Run mypy Python typechecker on linter scripts.

 lint-linters:

   variables:

     GIT_DEPTH: 1

     GIT_SUBMODULE_STRATEGY: none

   script:

     - mypy testsuite/tests/linters/regex-linters/*.py

   dependencies: []

 # Check that .T files all parse by listing broken tests.

 lint-testsuite:

   variables:

     GIT_DEPTH: 1

     GIT_SUBMODULE_STRATEGY: none

   script:

   dependencies: []

 # Run mypy Python typechecker on testsuite driver

 typecheck-testsuite:

   variables:

     GIT_DEPTH: 1

     GIT_SUBMODULE_STRATEGY: none

   script:

     - mypy testsuite/driver/runtests.py

   dependencies: []

 # accommodate, e.g., haddock changes not yet upstream) but not on `master` or

 # Marge jobs.

 .lint-submods:

   extends: .lint-params

   variables:

     BUILD_FLAVOUR: default

 # Check that commits in an MR were not authored with the identity that CI uses

 # when it needs to create commits itself. This only needs Git history.

 lint-author:

   variables:

     GIT_SUBMODULE_STRATEGY: none

   script:

     - git fetch "$CI_MERGE_REQUEST_PROJECT_URL" $CI_MERGE_REQUEST_TARGET_BRANCH_NAME

     - base="$(git merge-base FETCH_HEAD $CI_COMMIT_SHA)"

 .lint-params:

   needs: []

   extends: .lint

   before_script:

     - .gitlab/ci.sh setup

   after_script:

     - .gitlab/ci.sh save_cache

 hadrian-ghc-in-ghci:

   stage: quick-build

   needs:

     - job: lint-linters

     - job: lint-submods

       optional: true

   variables:

     GHC_FLAGS: -Werror -Wwarn=unused-imports

   script:

     - git clean -xdf && git submodule foreach git clean -xdf

     - . .gitlab/ci.sh setup

   extends: hadrian-ghc-in-ghci

   stage: quick-build

   script:

     - . .gitlab/ci.sh setup

     - . .gitlab/ci.sh configure

     - hadrian/build-stack --version

 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

         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)

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

 +    In an equation for ‘idV’: idV !v = ...

 So we live with the duplication.

 -}

         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

 -- | Use -XStrict to add a ! or remove a ~

 -- See Note [decideBangHood]

 decideBangHood :: DynFlags

                -> LPat GhcTc  -- ^ Original pattern

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

            LazyPat _ lp' -> lp'

            BangPat _ _   -> lp

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

 maxDmd :: Demand -> Demand -> Demand

 maxDmd BotDmd      dmd2        = dmd2

 maxDmd dmd1        BotDmd      = dmd1

 maxDmd (n1 :* sd1) (n2 :* sd2) =

   maxCard n1 n2 :* maxSubDmd sd1 sd2

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

 test('T26416', [extra_files(['M1.hs'])], multimod_compile_and_run, ['T26416','M1.hs'])

 test('T27626', [extra_files(['M2.hs'])], multimod_compile_and_run, ['T27626','M2.hs'])

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

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

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

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