    {-# LANGUAGE TypeApplications #-}
    {-# LANGUAGE CPP                 #-}
    {-# LANGUAGE DeriveFunctor       #-}
    {-# LANGUAGE FlexibleContexts    #-}
    {-# LANGUAGE RankNTypes          #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies        #-}
    {-# LANGUAGE ViewPatterns        #-}

    {-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}
    {-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

    {-
    (c) The GRASP/AQUA Project, Glasgow University, 1992-1998

    Renaming of patterns

    Basically dependency analysis.

    Handles @Match@, @GRHSs@, @HsExpr@, and @Qualifier@ datatypes.  In
    general, all of these functions return a renamed thing, and a set of
    free variables.
    -}
    module GHC.Rename.Pat (-- main entry points
                  rnPat, rnPats, rnBindPat, rnPatAndThen,

                  NameMaker, applyNameMaker,     -- a utility for making names:
                  localRecNameMaker, topRecNameMaker,  --   sometimes we want to make local names,
                                                 --   sometimes we want to make top (qualified) names.
                  isTopRecNameMaker,

                  rnHsRecFields, HsRecFieldContext(..),
                  rnHsRecUpdFields,

                  -- CpsRn monad
                  CpsRn, liftCps, liftCpsWithCont,

                  -- Literals
                  rnLit, rnOverLit,

                 -- Pattern Error message that is also used elsewhere
                 patSigErr
                 ) where

    -- ENH: thin imports to only what is necessary for patterns

    import GHC.Prelude

    import {-# SOURCE #-} GHC.Rename.Expr ( rnLExpr )
    import {-# SOURCE #-} GHC.Rename.Splice ( rnSplicePat )

    #include "HsVersions.h"

    import GHC.Hs
    import GHC.Tc.Utils.Monad
    import GHC.Tc.Utils.Zonk   ( hsOverLitName )
    import GHC.Rename.Env
    import GHC.Rename.Fixity
    import GHC.Rename.Utils    ( HsDocContext(..), newLocalBndrRn, bindLocalNames
                               , warnUnusedMatches, newLocalBndrRn
                               , checkUnusedRecordWildcard
                               , checkDupNames, checkDupAndShadowedNames )
    import GHC.Rename.HsType
    import GHC.Builtin.Names
    import GHC.Types.Avail ( greNameMangledName )
    import GHC.Types.Name
    import GHC.Types.Name.Set
    import GHC.Types.Name.Reader
    import GHC.Types.Basic
    import GHC.Types.SourceText
    import GHC.Utils.Misc
    import GHC.Data.List.SetOps( removeDups )
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Types.SrcLoc
    import GHC.Types.Literal   ( inCharRange )
    import GHC.Builtin.Types   ( nilDataCon )
    import GHC.Core.DataCon
    import GHC.Driver.Session ( getDynFlags, xopt_DuplicateRecordFields )
    import qualified GHC.LanguageExtensions as LangExt

    import Control.Monad       ( when, ap, guard, forM, unless )
    import qualified Data.List.NonEmpty as NE
    import Data.Maybe
    import Data.Ratio
    import GHC.Types.FieldLabel (DuplicateRecordFields(..))

    {-
    *********************************************************
    *                                                      *
            The CpsRn Monad
    *                                                      *
    *********************************************************

    Note [CpsRn monad]
    ~~~~~~~~~~~~~~~~~~
    The CpsRn monad uses continuation-passing style to support this
    style of programming:

            do { ...
               ; ns <- bindNames rs
               ; ...blah... }

       where rs::[RdrName], ns::[Name]

    The idea is that '...blah...'
      a) sees the bindings of ns
      b) returns the free variables it mentions
         so that bindNames can report unused ones

    In particular,
        mapM rnPatAndThen [p1, p2, p3]
    has a *left-to-right* scoping: it makes the binders in
    p1 scope over p2,p3.
    -}

    newtype CpsRn b = CpsRn { forall b.
    CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    unCpsRn :: forall r. (b -> RnM (r, FreeVars))
                                                -> RnM (r, FreeVars) }
            deriving ((forall a b. (a -> b) -> CpsRn a -> CpsRn b)
    -> (forall a b. a -> CpsRn b -> CpsRn a) -> Functor CpsRn
    forall a b. a -> CpsRn b -> CpsRn a
    forall a b. (a -> b) -> CpsRn a -> CpsRn b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> CpsRn b -> CpsRn a
    $c<$ :: forall a b. a -> CpsRn b -> CpsRn a
    fmap :: forall a b. (a -> b) -> CpsRn a -> CpsRn b
    $cfmap :: forall a b. (a -> b) -> CpsRn a -> CpsRn b
    Functor)
            -- See Note [CpsRn monad]

    instance Applicative CpsRn where
        pure :: forall a. a -> CpsRn a
    pure a
    x = (forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn a
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\a -> RnM (r, FreeVars)
    k -> a -> RnM (r, FreeVars)
    k a
    x)
        <*> :: forall a b. CpsRn (a -> b) -> CpsRn a -> CpsRn b
    (<*>) = CpsRn (a -> b) -> CpsRn a -> CpsRn b
    forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
    ap

    instance Monad CpsRn where
      (CpsRn forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    m) >>= :: forall a b. CpsRn a -> (a -> CpsRn b) -> CpsRn b
    >>= a -> CpsRn b
    mk = (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\b -> RnM (r, FreeVars)
    k -> (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    m (\a
    v -> CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    forall b.
    CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    unCpsRn (a -> CpsRn b
    mk a
    v) b -> RnM (r, FreeVars)
    k))

    runCps :: CpsRn a -> RnM (a, FreeVars)
    runCps :: forall a. CpsRn a -> RnM (a, FreeVars)
    runCps (CpsRn forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    m) = (a -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
    forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    m (\a
    r -> (a, FreeVars) -> RnM (a, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    r, FreeVars
    emptyFVs))

    liftCps :: RnM a -> CpsRn a
    liftCps :: forall a. RnM a -> CpsRn a
    liftCps RnM a
    rn_thing = (forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn a
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\a -> RnM (r, FreeVars)
    k -> RnM a
    rn_thing RnM a -> (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= a -> RnM (r, FreeVars)
    k)

    liftCpsFV :: RnM (a, FreeVars) -> CpsRn a
    liftCpsFV :: forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV RnM (a, FreeVars)
    rn_thing = (forall r. (a -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn a
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\a -> RnM (r, FreeVars)
    k -> do { (a
    v,FreeVars
    fvs1) <- RnM (a, FreeVars)
    rn_thing
                                         ; (r
    r,FreeVars
    fvs2) <- a -> RnM (r, FreeVars)
    k a
    v
                                         ; (r, FreeVars) -> RnM (r, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (r
    r, FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs2) })

    liftCpsWithCont :: (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)) -> CpsRn b
    liftCpsWithCont :: forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    liftCpsWithCont = (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn

    wrapSrcSpanCps :: (a -> CpsRn b) -> LocatedA a -> CpsRn (LocatedA b)
    -- Set the location, and also wrap it around the value returned
    wrapSrcSpanCps :: forall a b. (a -> CpsRn b) -> LocatedA a -> CpsRn (LocatedA b)
    wrapSrcSpanCps a -> CpsRn b
    fn (L SrcSpanAnnA
    loc a
    a)
      = (forall r. (LocatedA b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn (LocatedA b)
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\LocatedA b -> RnM (r, FreeVars)
    k -> SrcSpanAnnA -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall ann a. SrcSpanAnn' ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (RnM (r, FreeVars) -> RnM (r, FreeVars))
    -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a b. (a -> b) -> a -> b
    $
                     CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    forall b.
    CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    unCpsRn (a -> CpsRn b
    fn a
    a) ((b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \b
    v ->
                     LocatedA b -> RnM (r, FreeVars)
    k (SrcSpanAnnA -> b -> LocatedA b
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    loc b
    v))

    lookupConCps :: LocatedN RdrName -> CpsRn (LocatedN Name)
    lookupConCps :: GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    lookupConCps GenLocated (SrcAnn NameAnn) RdrName
    con_rdr
      = (forall r.
     (LocatedN Name -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn (LocatedN Name)
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\LocatedN Name -> RnM (r, FreeVars)
    k -> do { LocatedN Name
    con_name <- GenLocated (SrcAnn NameAnn) RdrName -> TcRn (LocatedN Name)
    forall ann.
    GenLocated (SrcSpanAnn' ann) RdrName
    -> TcRn (GenLocated (SrcSpanAnn' ann) Name)
    lookupLocatedOccRn GenLocated (SrcAnn NameAnn) RdrName
    con_rdr
                        ; (r
    r, FreeVars
    fvs) <- LocatedN Name -> RnM (r, FreeVars)
    k LocatedN Name
    con_name
                        ; (r, FreeVars) -> RnM (r, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (r
    r, FreeVars -> Name -> FreeVars
    addOneFV FreeVars
    fvs (LocatedN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LocatedN Name
    con_name)) })
        -- We add the constructor name to the free vars
        -- See Note [Patterns are uses]

    {-
    Note [Patterns are uses]
    ~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      module Foo( f, g ) where
      data T = T1 | T2

      f T1 = True
      f T2 = False

      g _ = T1

    Arguably we should report T2 as unused, even though it appears in a
    pattern, because it never occurs in a constructed position.
    See #7336.
    However, implementing this in the face of pattern synonyms would be
    less straightforward, since given two pattern synonyms

      pattern P1 <- P2
      pattern P2 <- ()

    we need to observe the dependency between P1 and P2 so that type
    checking can be done in the correct order (just like for value
    bindings). Dependencies between bindings is analyzed in the renamer,
    where we don't know yet whether P2 is a constructor or a pattern
    synonym. So for now, we do report conid occurrences in patterns as
    uses.

    *********************************************************
    *                                                      *
            Name makers
    *                                                      *
    *********************************************************

    Externally abstract type of name makers,
    which is how you go from a RdrName to a Name
    -}

    data NameMaker
      = LamMk       -- Lambdas
          Bool      -- True <=> report unused bindings
                    --   (even if True, the warning only comes out
                    --    if -Wunused-matches is on)

      | LetMk       -- Let bindings, incl top level
                    -- Do *not* check for unused bindings
          TopLevelFlag
          MiniFixityEnv

    topRecNameMaker :: MiniFixityEnv -> NameMaker
    topRecNameMaker :: MiniFixityEnv -> NameMaker
    topRecNameMaker MiniFixityEnv
    fix_env = TopLevelFlag -> MiniFixityEnv -> NameMaker
    LetMk TopLevelFlag
    TopLevel MiniFixityEnv
    fix_env

    isTopRecNameMaker :: NameMaker -> Bool
    isTopRecNameMaker :: NameMaker -> Bool
    isTopRecNameMaker (LetMk TopLevelFlag
    TopLevel MiniFixityEnv
    _) = Bool
    True
    isTopRecNameMaker NameMaker
    _ = Bool
    False

    localRecNameMaker :: MiniFixityEnv -> NameMaker
    localRecNameMaker :: MiniFixityEnv -> NameMaker
    localRecNameMaker MiniFixityEnv
    fix_env = TopLevelFlag -> MiniFixityEnv -> NameMaker
    LetMk TopLevelFlag
    NotTopLevel MiniFixityEnv
    fix_env

    matchNameMaker :: HsMatchContext a -> NameMaker
    matchNameMaker :: forall a. HsMatchContext a -> NameMaker
    matchNameMaker HsMatchContext a
    ctxt = Bool -> NameMaker
    LamMk Bool
    report_unused
      where
        -- Do not report unused names in interactive contexts
        -- i.e. when you type 'x <- e' at the GHCi prompt
        report_unused :: Bool
    report_unused = case HsMatchContext a
    ctxt of
                          StmtCtxt HsStmtContext a
    GhciStmtCtxt -> Bool
    False
                          -- also, don't warn in pattern quotes, as there
                          -- is no RHS where the variables can be used!
                          HsMatchContext a
    ThPatQuote            -> Bool
    False
                          HsMatchContext a
    _                     -> Bool
    True

    newPatLName :: NameMaker -> LocatedN RdrName -> CpsRn (LocatedN Name)
    newPatLName :: NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    newPatLName NameMaker
    name_maker rdr_name :: GenLocated (SrcAnn NameAnn) RdrName
    rdr_name@(L SrcAnn NameAnn
    loc RdrName
    _)
      = do { Name
    name <- NameMaker -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn Name
    newPatName NameMaker
    name_maker GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
           ; LocatedN Name -> CpsRn (LocatedN Name)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcAnn NameAnn -> Name -> LocatedN Name
    forall l e. l -> e -> GenLocated l e
    L SrcAnn NameAnn
    loc Name
    name) }

    newPatName :: NameMaker -> LocatedN RdrName -> CpsRn Name
    newPatName :: NameMaker -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn Name
    newPatName (LamMk Bool
    report_unused) GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
      = (forall r. (Name -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn Name
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\ Name -> RnM (r, FreeVars)
    thing_inside ->
            do { Name
    name <- GenLocated (SrcAnn NameAnn) RdrName -> RnM Name
    newLocalBndrRn GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
               ; (r
    res, FreeVars
    fvs) <- [Name] -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a. [Name] -> RnM a -> RnM a
    bindLocalNames [Name
    name] (Name -> RnM (r, FreeVars)
    thing_inside Name
    name)
               ; Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when Bool
    report_unused (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
    warnUnusedMatches [Name
    name] FreeVars
    fvs
               ; (r, FreeVars) -> RnM (r, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (r
    res, Name
    name Name -> FreeVars -> FreeVars
    `delFV` FreeVars
    fvs) })

    newPatName (LetMk TopLevelFlag
    is_top MiniFixityEnv
    fix_env) GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
      = (forall r. (Name -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn Name
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\ Name -> RnM (r, FreeVars)
    thing_inside ->
            do { Name
    name <- case TopLevelFlag
    is_top of
                           TopLevelFlag
    NotTopLevel -> GenLocated (SrcAnn NameAnn) RdrName -> RnM Name
    newLocalBndrRn GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
                           TopLevelFlag
    TopLevel    -> GenLocated (SrcAnn NameAnn) RdrName -> RnM Name
    newTopSrcBinder GenLocated (SrcAnn NameAnn) RdrName
    rdr_name
               ; [Name] -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a. [Name] -> RnM a -> RnM a
    bindLocalNames [Name
    name] (RnM (r, FreeVars) -> RnM (r, FreeVars))
    -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a b. (a -> b) -> a -> b
    $
                     -- Do *not* use bindLocalNameFV here;
                     --   see Note [View pattern usage]
                     -- For the TopLevel case
                     --   see Note [bindLocalNames for an External name]
                 MiniFixityEnv -> [Name] -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a. MiniFixityEnv -> [Name] -> RnM a -> RnM a
    addLocalFixities MiniFixityEnv
    fix_env [Name
    name] (RnM (r, FreeVars) -> RnM (r, FreeVars))
    -> RnM (r, FreeVars) -> RnM (r, FreeVars)
    forall a b. (a -> b) -> a -> b
    $
                 Name -> RnM (r, FreeVars)
    thing_inside Name
    name })

    {- Note [bindLocalNames for an External name]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In the TopLevel case, the use of bindLocalNames here is somewhat
    suspicious because it binds a top-level External name in the
    LocalRdrEnv.  c.f. Note [LocalRdrEnv] in GHC.Types.Name.Reader.

    However, this only happens when renaming the LHS (only) of a top-level
    pattern binding.  Even though this only the LHS, we need to bring the
    binder into scope in the pattern itself in case the binder is used in
    subsequent view patterns.  A bit bizarre, something like
      (x, Just y <- f x) = e

    Anyway, bindLocalNames does work, and the binding only exists for the
    duration of the pattern; then the top-level name is added to the
    global env before going on to the RHSes (see GHC.Rename.Module).

    Note [View pattern usage]
    ~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      let (r, (r -> x)) = x in ...
    Here the pattern binds 'r', and then uses it *only* in the view pattern.
    We want to "see" this use, and in let-bindings we collect all uses and
    report unused variables at the binding level. So we must use bindLocalNames
    here, *not* bindLocalNameFV.  #3943.

    Note [Don't report shadowing for pattern synonyms]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    There is one special context where a pattern doesn't introduce any new binders -
    pattern synonym declarations. Therefore we don't check to see if pattern
    variables shadow existing identifiers as they are never bound to anything
    and have no scope.

    Without this check, there would be quite a cryptic warning that the `x`
    in the RHS of the pattern synonym declaration shadowed the top level `x`.

    ```
    x :: ()
    x = ()

    pattern P x = Just x
    ```

    See #12615 for some more examples.

    *********************************************************
    *                                                      *
            External entry points
    *                                                      *
    *********************************************************

    There are various entry points to renaming patterns, depending on
     (1) whether the names created should be top-level names or local names
     (2) whether the scope of the names is entirely given in a continuation
         (e.g., in a case or lambda, but not in a let or at the top-level,
          because of the way mutually recursive bindings are handled)
     (3) whether the a type signature in the pattern can bind
            lexically-scoped type variables (for unpacking existential
            type vars in data constructors)
     (4) whether we do duplicate and unused variable checking
     (5) whether there are fixity declarations associated with the names
         bound by the patterns that need to be brought into scope with them.

     Rather than burdening the clients of this module with all of these choices,
     we export the three points in this design space that we actually need:
    -}

    -- ----------- Entry point 1: rnPats -------------------
    -- Binds local names; the scope of the bindings is entirely in the thing_inside
    --   * allows type sigs to bind type vars
    --   * local namemaker
    --   * unused and duplicate checking
    --   * no fixities
    rnPats :: HsMatchContext GhcRn -- for error messages
           -> [LPat GhcPs]
           -> ([LPat GhcRn] -> RnM (a, FreeVars))
           -> RnM (a, FreeVars)
    rnPats :: forall a.
    HsMatchContext GhcRn
    -> [LPat GhcPs]
    -> ([LPat GhcRn] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    rnPats HsMatchContext GhcRn
    ctxt [LPat GhcPs]
    pats [LPat GhcRn] -> RnM (a, FreeVars)
    thing_inside
      = do  { (GlobalRdrEnv, LocalRdrEnv)
    envs_before <- TcRn (GlobalRdrEnv, LocalRdrEnv)
    getRdrEnvs

              -- (1) rename the patterns, bringing into scope all of the term variables
              -- (2) then do the thing inside.
            ; CpsRn [GenLocated SrcSpanAnnA (Pat GhcRn)]
    -> forall r.
       ([GenLocated SrcSpanAnnA (Pat GhcRn)] -> RnM (r, FreeVars))
       -> RnM (r, FreeVars)
    forall b.
    CpsRn b -> forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars)
    unCpsRn (NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen (HsMatchContext GhcRn -> NameMaker
    forall a. HsMatchContext a -> NameMaker
    matchNameMaker HsMatchContext GhcRn
    ctxt) [LPat GhcPs]
    pats) (([GenLocated SrcSpanAnnA (Pat GhcRn)] -> RnM (a, FreeVars))
     -> RnM (a, FreeVars))
    -> ([GenLocated SrcSpanAnnA (Pat GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ [GenLocated SrcSpanAnnA (Pat GhcRn)]
    pats' -> do
            { -- Check for duplicated and shadowed names
              -- Must do this *after* renaming the patterns
              -- See Note [Collect binders only after renaming] in GHC.Hs.Utils
              -- Because we don't bind the vars all at once, we can't
              --    check incrementally for duplicates;
              -- Nor can we check incrementally for shadowing, else we'll
              --    complain *twice* about duplicates e.g. f (x,x) = ...
              --
              -- See note [Don't report shadowing for pattern synonyms]
            ; let bndrs :: [IdP GhcRn]
    bndrs = CollectFlag GhcRn -> [LPat GhcRn] -> [IdP GhcRn]
    forall p. CollectPass p => CollectFlag p -> [LPat p] -> [IdP p]
    collectPatsBinders CollectFlag GhcRn
    forall p. CollectFlag p
    CollNoDictBinders [GenLocated SrcSpanAnnA (Pat GhcRn)]
    [LPat GhcRn]
    pats'
            ; SDoc
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a. SDoc -> TcM a -> TcM a
    addErrCtxt SDoc
    doc_pat (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
              if HsMatchContext GhcRn -> Bool
    forall p. HsMatchContext p -> Bool
    isPatSynCtxt HsMatchContext GhcRn
    ctxt
                 then [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupNames [Name]
    [IdP GhcRn]
    bndrs
                 else (GlobalRdrEnv, LocalRdrEnv)
    -> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkDupAndShadowedNames (GlobalRdrEnv, LocalRdrEnv)
    envs_before [Name]
    [IdP GhcRn]
    bndrs
            ; [LPat GhcRn] -> RnM (a, FreeVars)
    thing_inside [GenLocated SrcSpanAnnA (Pat GhcRn)]
    [LPat GhcRn]
    pats' } }
      where
        doc_pat :: SDoc
    doc_pat = String -> SDoc
    text String
    "In" SDoc -> SDoc -> SDoc
    <+> HsMatchContext GhcRn -> SDoc
    forall p.
    (Outputable (IdP p), UnXRec p) =>
    HsMatchContext p -> SDoc
    pprMatchContext HsMatchContext GhcRn
    ctxt

    rnPat :: HsMatchContext GhcRn -- for error messages
          -> LPat GhcPs
          -> (LPat GhcRn -> RnM (a, FreeVars))
          -> RnM (a, FreeVars)     -- Variables bound by pattern do not
                                   -- appear in the result FreeVars
    rnPat :: forall a.
    HsMatchContext GhcRn
    -> LPat GhcPs
    -> (LPat GhcRn -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    rnPat HsMatchContext GhcRn
    ctxt LPat GhcPs
    pat LPat GhcRn -> RnM (a, FreeVars)
    thing_inside
      = HsMatchContext GhcRn
    -> [LPat GhcPs]
    -> ([LPat GhcRn] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a.
    HsMatchContext GhcRn
    -> [LPat GhcPs]
    -> ([LPat GhcRn] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    rnPats HsMatchContext GhcRn
    ctxt [LPat GhcPs
    pat] (\[LPat GhcRn]
    pats' -> let [LPat GhcRn
    pat'] = [LPat GhcRn]
    pats' in LPat GhcRn -> RnM (a, FreeVars)
    thing_inside LPat GhcRn
    pat')

    applyNameMaker :: NameMaker -> LocatedN RdrName -> RnM (LocatedN Name)
    applyNameMaker :: NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName -> TcRn (LocatedN Name)
    applyNameMaker NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    rdr = do { (LocatedN Name
    n, FreeVars
    _fvs) <- CpsRn (LocatedN Name) -> RnM (LocatedN Name, FreeVars)
    forall a. CpsRn a -> RnM (a, FreeVars)
    runCps (NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    newPatLName NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    rdr)
                               ; LocatedN Name -> TcRn (LocatedN Name)
    forall (m :: * -> *) a. Monad m => a -> m a
    return LocatedN Name
    n }

    -- ----------- Entry point 2: rnBindPat -------------------
    -- Binds local names; in a recursive scope that involves other bound vars
    --      e.g let { (x, Just y) = e1; ... } in ...
    --   * does NOT allows type sig to bind type vars
    --   * local namemaker
    --   * no unused and duplicate checking
    --   * fixities might be coming in
    rnBindPat :: NameMaker
              -> LPat GhcPs
              -> RnM (LPat GhcRn, FreeVars)
       -- Returned FreeVars are the free variables of the pattern,
       -- of course excluding variables bound by this pattern

    rnBindPat :: NameMaker -> LPat GhcPs -> RnM (LPat GhcRn, FreeVars)
    rnBindPat NameMaker
    name_maker LPat GhcPs
    pat = CpsRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    -> RnM (GenLocated SrcSpanAnnA (Pat GhcRn), FreeVars)
    forall a. CpsRn a -> RnM (a, FreeVars)
    runCps (NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    name_maker LPat GhcPs
    pat)

    {-
    *********************************************************
    *                                                      *
            The main event
    *                                                      *
    *********************************************************
    -}

    -- ----------- Entry point 3: rnLPatAndThen -------------------
    -- General version: parametrized by how you make new names

    rnLPatsAndThen :: NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen :: NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen NameMaker
    mk = (GenLocated SrcSpanAnnA (Pat GhcPs)
     -> CpsRn (GenLocated SrcSpanAnnA (Pat GhcRn)))
    -> [GenLocated SrcSpanAnnA (Pat GhcPs)]
    -> CpsRn [GenLocated SrcSpanAnnA (Pat GhcRn)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk)
      -- Despite the map, the monad ensures that each pattern binds
      -- variables that may be mentioned in subsequent patterns in the list

    --------------------
    -- The workhorse
    rnLPatAndThen :: NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen :: NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    nm LPat GhcPs
    lpat = (Pat GhcPs -> CpsRn (Pat GhcRn))
    -> GenLocated SrcSpanAnnA (Pat GhcPs)
    -> CpsRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    forall a b. (a -> CpsRn b) -> LocatedA a -> CpsRn (LocatedA b)
    wrapSrcSpanCps (NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    nm) GenLocated SrcSpanAnnA (Pat GhcPs)
    LPat GhcPs
    lpat

    rnPatAndThen :: NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen :: NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    _  (WildPat XWildPat GhcPs
    _)   = Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XWildPat GhcRn -> Pat GhcRn
    forall p. XWildPat p -> Pat p
    WildPat NoExtField
    XWildPat GhcRn
    noExtField)
    rnPatAndThen NameMaker
    mk (ParPat XParPat GhcPs
    x LPat GhcPs
    pat)  = do { GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
                                         ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XParPat GhcRn -> LPat GhcRn -> Pat GhcRn
    forall p. XParPat p -> LPat p -> Pat p
    ParPat XParPat GhcPs
    XParPat GhcRn
    x GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat') }
    rnPatAndThen NameMaker
    mk (LazyPat XLazyPat GhcPs
    _ LPat GhcPs
    pat) = do { GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
                                         ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XLazyPat GhcRn -> LPat GhcRn -> Pat GhcRn
    forall p. XLazyPat p -> LPat p -> Pat p
    LazyPat NoExtField
    XLazyPat GhcRn
    noExtField GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat') }
    rnPatAndThen NameMaker
    mk (BangPat XBangPat GhcPs
    _ LPat GhcPs
    pat) = do { GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
                                         ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XBangPat GhcRn -> LPat GhcRn -> Pat GhcRn
    forall p. XBangPat p -> LPat p -> Pat p
    BangPat NoExtField
    XBangPat GhcRn
    noExtField GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat') }
    rnPatAndThen NameMaker
    mk (VarPat XVarPat GhcPs
    x (L SrcAnn NameAnn
    l RdrName
    rdr))
        = do { SrcSpan
    loc <- RnM SrcSpan -> CpsRn SrcSpan
    forall a. RnM a -> CpsRn a
    liftCps RnM SrcSpan
    getSrcSpanM
             ; Name
    name <- NameMaker -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn Name
    newPatName NameMaker
    mk (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) RdrName
    rdr)
             ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XVarPat GhcRn -> LIdP GhcRn -> Pat GhcRn
    forall p. XVarPat p -> LIdP p -> Pat p
    VarPat XVarPat GhcPs
    XVarPat GhcRn
    x (SrcAnn NameAnn -> Name -> LocatedN Name
    forall l e. l -> e -> GenLocated l e
    L SrcAnn NameAnn
    l Name
    name)) }
         -- we need to bind pattern variables for view pattern expressions
         -- (e.g. in the pattern (x, x -> y) x needs to be bound in the rhs of the tuple)

    rnPatAndThen NameMaker
    mk (SigPat XSigPat GhcPs
    _ LPat GhcPs
    pat HsPatSigType (NoGhcTc GhcPs)
    sig)
      -- When renaming a pattern type signature (e.g. f (a :: T) = ...), it is
      -- important to rename its type signature _before_ renaming the rest of the
      -- pattern, so that type variables are first bound by the _outermost_ pattern
      -- type signature they occur in. This keeps the type checker happy when
      -- pattern type signatures happen to be nested (#7827)
      --
      -- f ((Just (x :: a) :: Maybe a)
      -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~^       `a' is first bound here
      -- ~~~~~~~~~~~~~~~^                   the same `a' then used here
      = do { HsPatSigType GhcRn
    sig' <- HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn)
    rnHsPatSigTypeAndThen HsPatSigType (NoGhcTc GhcPs)
    HsPatSigType GhcPs
    sig
           ; GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XSigPat GhcRn
    -> LPat GhcRn -> HsPatSigType (NoGhcTc GhcRn) -> Pat GhcRn
    forall p. XSigPat p -> LPat p -> HsPatSigType (NoGhcTc p) -> Pat p
    SigPat NoExtField
    XSigPat GhcRn
    noExtField GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat' HsPatSigType (NoGhcTc GhcRn)
    HsPatSigType GhcRn
    sig' ) }
      where
        rnHsPatSigTypeAndThen :: HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn)
        rnHsPatSigTypeAndThen :: HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn)
    rnHsPatSigTypeAndThen HsPatSigType GhcPs
    sig = (forall r.
     (HsPatSigType GhcRn -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn (HsPatSigType GhcRn)
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    liftCpsWithCont (HsPatSigTypeScoping
    -> HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (r, FreeVars))
    -> RnM (r, FreeVars)
    forall a.
    HsPatSigTypeScoping
    -> HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    rnHsPatSigType HsPatSigTypeScoping
    AlwaysBind HsDocContext
    PatCtx HsPatSigType GhcPs
    sig)

    rnPatAndThen NameMaker
    mk (LitPat XLitPat GhcPs
    x HsLit GhcPs
    lit)
      | HsString XHsString GhcPs
    src FastString
    s <- HsLit GhcPs
    lit
      = do { Bool
    ovlStr <- RnM Bool -> CpsRn Bool
    forall a. RnM a -> CpsRn a
    liftCps (Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.OverloadedStrings)
           ; if Bool
    ovlStr
             then NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    mk
                               (Located (HsOverLit GhcPs)
    -> Maybe (SyntaxExpr GhcPs) -> EpAnn [AddEpAnn] -> Pat GhcPs
    mkNPat (HsOverLit GhcPs -> Located (HsOverLit GhcPs)
    forall e. e -> Located e
    noLoc (SourceText -> FastString -> HsOverLit GhcPs
    mkHsIsString SourceText
    XHsString GhcPs
    src FastString
    s))
                                          Maybe (SyntaxExpr GhcPs)
    forall a. Maybe a
    Nothing EpAnn [AddEpAnn]
    forall a. EpAnn a
    noAnn)
             else CpsRn (Pat GhcRn)
    normal_lit }
      | Bool
    otherwise = CpsRn (Pat GhcRn)
    normal_lit
      where
        normal_lit :: CpsRn (Pat GhcRn)
    normal_lit = do { IOEnv (Env TcGblEnv TcLclEnv) () -> CpsRn ()
    forall a. RnM a -> CpsRn a
    liftCps (HsLit GhcPs -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall p. HsLit p -> IOEnv (Env TcGblEnv TcLclEnv) ()
    rnLit HsLit GhcPs
    lit); Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XLitPat GhcRn -> HsLit GhcRn -> Pat GhcRn
    forall p. XLitPat p -> HsLit p -> Pat p
    LitPat XLitPat GhcPs
    XLitPat GhcRn
    x (HsLit GhcPs -> HsLit GhcRn
    forall (p1 :: Pass) (p2 :: Pass).
    HsLit (GhcPass p1) -> HsLit (GhcPass p2)
    convertLit HsLit GhcPs
    lit)) }

    rnPatAndThen NameMaker
    _ (NPat XNPat GhcPs
    x (L SrcSpan
    l HsOverLit GhcPs
    lit) Maybe (SyntaxExpr GhcPs)
    mb_neg SyntaxExpr GhcPs
    _eq)
      = do { (HsOverLit GhcRn
    lit', Maybe (HsExpr GhcRn)
    mb_neg') <- RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn))
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
     -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn)))
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn))
    forall a b. (a -> b) -> a -> b
    $ HsOverLit GhcPs
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    forall t.
    HsOverLit t
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    rnOverLit HsOverLit GhcPs
    lit
           ; Maybe SyntaxExprRn
    mb_neg' -- See Note [Negative zero]
               <- let negative :: IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    negative = do { (SyntaxExprRn
    neg, FreeVars
    fvs) <- Name -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupSyntax Name
    negateName
                                    ; (Maybe SyntaxExprRn, FreeVars)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SyntaxExprRn -> Maybe SyntaxExprRn
    forall a. a -> Maybe a
    Just SyntaxExprRn
    neg, FreeVars
    fvs) }
                      positive :: IOEnv (Env TcGblEnv TcLclEnv) (Maybe a, FreeVars)
    positive = (Maybe a, FreeVars)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe a, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe a
    forall a. Maybe a
    Nothing, FreeVars
    emptyFVs)
                  in IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    -> CpsRn (Maybe SyntaxExprRn)
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
     -> CpsRn (Maybe SyntaxExprRn))
    -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    -> CpsRn (Maybe SyntaxExprRn)
    forall a b. (a -> b) -> a -> b
    $ case (Maybe NoExtField
    Maybe (SyntaxExpr GhcPs)
    mb_neg , Maybe (HsExpr GhcRn)
    mb_neg') of
                                      (Maybe NoExtField
    Nothing, Just HsExpr GhcRn
    _ ) -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    negative
                                      (Just NoExtField
    _ , Maybe (HsExpr GhcRn)
    Nothing) -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    negative
                                      (Maybe NoExtField
    Nothing, Maybe (HsExpr GhcRn)
    Nothing) -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    forall {a}. IOEnv (Env TcGblEnv TcLclEnv) (Maybe a, FreeVars)
    positive
                                      (Just NoExtField
    _ , Just HsExpr GhcRn
    _ ) -> IOEnv (Env TcGblEnv TcLclEnv) (Maybe SyntaxExprRn, FreeVars)
    forall {a}. IOEnv (Env TcGblEnv TcLclEnv) (Maybe a, FreeVars)
    positive
           ; SyntaxExprRn
    eq' <- RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn))
    -> RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ Name -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupSyntax Name
    eqName
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XNPat GhcRn
    -> XRec GhcRn (HsOverLit GhcRn)
    -> Maybe (SyntaxExpr GhcRn)
    -> SyntaxExpr GhcRn
    -> Pat GhcRn
    forall p.
    XNPat p
    -> XRec p (HsOverLit p)
    -> Maybe (SyntaxExpr p)
    -> SyntaxExpr p
    -> Pat p
    NPat XNPat GhcPs
    XNPat GhcRn
    x (SrcSpan -> HsOverLit GhcRn -> GenLocated SrcSpan (HsOverLit GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    l HsOverLit GhcRn
    lit') Maybe (SyntaxExpr GhcRn)
    Maybe SyntaxExprRn
    mb_neg' SyntaxExpr GhcRn
    SyntaxExprRn
    eq') }

    rnPatAndThen NameMaker
    mk (NPlusKPat XNPlusKPat GhcPs
    _ XRec GhcPs (IdP GhcPs)
    rdr (L SrcSpan
    l HsOverLit GhcPs
    lit) HsOverLit GhcPs
    _ SyntaxExpr GhcPs
    _ SyntaxExpr GhcPs
    _ )
      = do { Name
    new_name <- NameMaker -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn Name
    newPatName NameMaker
    mk (GenLocated (SrcAnn NameAnn) RdrName
    -> GenLocated (SrcAnn NameAnn) RdrName
    forall a1 a2. LocatedAn a1 a2 -> LocatedN a2
    l2n GenLocated (SrcAnn NameAnn) RdrName
    XRec GhcPs (IdP GhcPs)
    rdr)
           ; (HsOverLit GhcRn
    lit', Maybe (HsExpr GhcRn)
    _) <- RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn))
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
     -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn)))
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> CpsRn (HsOverLit GhcRn, Maybe (HsExpr GhcRn))
    forall a b. (a -> b) -> a -> b
    $ HsOverLit GhcPs
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    forall t.
    HsOverLit t
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    rnOverLit HsOverLit GhcPs
    lit -- See Note [Negative zero]
                                                    -- We skip negateName as
                                                    -- negative zero doesn't make
                                                    -- sense in n + k patterns
           ; SyntaxExprRn
    minus <- RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn))
    -> RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ Name -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupSyntax Name
    minusName
           ; SyntaxExprRn
    ge    <- RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn))
    -> RnM (SyntaxExpr GhcRn, FreeVars) -> CpsRn (SyntaxExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ Name -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupSyntax Name
    geName
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XNPlusKPat GhcRn
    -> LIdP GhcRn
    -> XRec GhcRn (HsOverLit GhcRn)
    -> HsOverLit GhcRn
    -> SyntaxExpr GhcRn
    -> SyntaxExpr GhcRn
    -> Pat GhcRn
    forall p.
    XNPlusKPat p
    -> LIdP p
    -> XRec p (HsOverLit p)
    -> HsOverLit p
    -> SyntaxExpr p
    -> SyntaxExpr p
    -> Pat p
    NPlusKPat NoExtField
    XNPlusKPat GhcRn
    noExtField (SrcAnn NameAnn -> Name -> LocatedN Name
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan (SrcSpan -> SrcAnn NameAnn) -> SrcSpan -> SrcAnn NameAnn
    forall a b. (a -> b) -> a -> b
    $ Name -> SrcSpan
    nameSrcSpan Name
    new_name) Name
    new_name)
                                          (SrcSpan -> HsOverLit GhcRn -> GenLocated SrcSpan (HsOverLit GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    l HsOverLit GhcRn
    lit') HsOverLit GhcRn
    lit' SyntaxExpr GhcRn
    SyntaxExprRn
    ge SyntaxExpr GhcRn
    SyntaxExprRn
    minus) }
                    -- The Report says that n+k patterns must be in Integral

    rnPatAndThen NameMaker
    mk (AsPat XAsPat GhcPs
    _ XRec GhcPs (IdP GhcPs)
    rdr LPat GhcPs
    pat)
      = do { LocatedN Name
    new_name <- NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    newPatLName NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    XRec GhcPs (IdP GhcPs)
    rdr
           ; GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XAsPat GhcRn -> LIdP GhcRn -> LPat GhcRn -> Pat GhcRn
    forall p. XAsPat p -> LIdP p -> LPat p -> Pat p
    AsPat NoExtField
    XAsPat GhcRn
    noExtField LocatedN Name
    LIdP GhcRn
    new_name GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat') }

    rnPatAndThen NameMaker
    mk p :: Pat GhcPs
    p@(ViewPat XViewPat GhcPs
    _ LHsExpr GhcPs
    expr LPat GhcPs
    pat)
      = do { IOEnv (Env TcGblEnv TcLclEnv) () -> CpsRn ()
    forall a. RnM a -> CpsRn a
    liftCps (IOEnv (Env TcGblEnv TcLclEnv) () -> CpsRn ())
    -> IOEnv (Env TcGblEnv TcLclEnv) () -> CpsRn ()
    forall a b. (a -> b) -> a -> b
    $ do { Bool
    vp_flag <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.ViewPatterns
                          ; Bool -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkErr Bool
    vp_flag (Pat GhcPs -> SDoc
    badViewPat Pat GhcPs
    p) }
             -- Because of the way we're arranging the recursive calls,
             -- this will be in the right context
           ; GenLocated SrcSpanAnnA (HsExpr GhcRn)
    expr' <- RnM (LHsExpr GhcRn, FreeVars) -> CpsRn (LHsExpr GhcRn)
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM (LHsExpr GhcRn, FreeVars) -> CpsRn (LHsExpr GhcRn))
    -> RnM (LHsExpr GhcRn, FreeVars) -> CpsRn (LHsExpr GhcRn)
    forall a b. (a -> b) -> a -> b
    $ LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
    rnLExpr LHsExpr GhcPs
    expr
           ; GenLocated SrcSpanAnnA (Pat GhcRn)
    pat' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
           -- Note: at this point the PreTcType in ty can only be a placeHolder
           -- ; return (ViewPat expr' pat' ty) }
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XViewPat GhcRn -> LHsExpr GhcRn -> LPat GhcRn -> Pat GhcRn
    forall p. XViewPat p -> LHsExpr p -> LPat p -> Pat p
    ViewPat NoExtField
    XViewPat GhcRn
    noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
    LHsExpr GhcRn
    expr' GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat') }

    rnPatAndThen NameMaker
    mk (ConPat XConPat GhcPs
    _ XRec GhcPs (ConLikeP GhcPs)
    con HsConPatDetails GhcPs
    args)
       -- rnConPatAndThen takes care of reconstructing the pattern
       -- The pattern for the empty list needs to be replaced by an empty explicit list pattern when overloaded lists is turned on.
      = case GenLocated (SrcAnn NameAnn) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated (SrcAnn NameAnn) RdrName
    XRec GhcPs (ConLikeP GhcPs)
    con RdrName -> RdrName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name -> RdrName
    nameRdrName (DataCon -> Name
    dataConName DataCon
    nilDataCon) of
          Bool
    True    -> do { Bool
    ol_flag <- RnM Bool -> CpsRn Bool
    forall a. RnM a -> CpsRn a
    liftCps (RnM Bool -> CpsRn Bool) -> RnM Bool -> CpsRn Bool
    forall a b. (a -> b) -> a -> b
    $ Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.OverloadedLists
                        ; if Bool
    ol_flag then NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    mk (XListPat GhcPs -> [LPat GhcPs] -> Pat GhcPs
    forall p. XListPat p -> [LPat p] -> Pat p
    ListPat XListPat GhcPs
    forall a. EpAnn a
    noAnn [])
                                     else NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName
    -> HsConPatDetails GhcPs
    -> CpsRn (Pat GhcRn)
    rnConPatAndThen NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    XRec GhcPs (ConLikeP GhcPs)
    con HsConPatDetails GhcPs
    args}
          Bool
    False   -> NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName
    -> HsConPatDetails GhcPs
    -> CpsRn (Pat GhcRn)
    rnConPatAndThen NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    XRec GhcPs (ConLikeP GhcPs)
    con HsConPatDetails GhcPs
    args

    rnPatAndThen NameMaker
    mk (ListPat XListPat GhcPs
    _ [LPat GhcPs]
    pats)
      = do { Bool
    opt_OverloadedLists <- RnM Bool -> CpsRn Bool
    forall a. RnM a -> CpsRn a
    liftCps (RnM Bool -> CpsRn Bool) -> RnM Bool -> CpsRn Bool
    forall a b. (a -> b) -> a -> b
    $ Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.OverloadedLists
           ; [GenLocated SrcSpanAnnA (Pat GhcRn)]
    pats' <- NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen NameMaker
    mk [LPat GhcPs]
    pats
           ; case Bool
    opt_OverloadedLists of
              Bool
    True -> do { (SyntaxExprRn
    to_list_name,FreeVars
    _) <- RnM (SyntaxExpr GhcRn, FreeVars)
    -> CpsRn (SyntaxExpr GhcRn, FreeVars)
    forall a. RnM a -> CpsRn a
    liftCps (RnM (SyntaxExpr GhcRn, FreeVars)
     -> CpsRn (SyntaxExpr GhcRn, FreeVars))
    -> RnM (SyntaxExpr GhcRn, FreeVars)
    -> CpsRn (SyntaxExpr GhcRn, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ Name -> RnM (SyntaxExpr GhcRn, FreeVars)
    lookupSyntax Name
    toListName
                         ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XListPat GhcRn -> [LPat GhcRn] -> Pat GhcRn
    forall p. XListPat p -> [LPat p] -> Pat p
    ListPat (SyntaxExprRn -> Maybe SyntaxExprRn
    forall a. a -> Maybe a
    Just SyntaxExprRn
    to_list_name) [GenLocated SrcSpanAnnA (Pat GhcRn)]
    [LPat GhcRn]
    pats')}
              Bool
    False -> Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XListPat GhcRn -> [LPat GhcRn] -> Pat GhcRn
    forall p. XListPat p -> [LPat p] -> Pat p
    ListPat XListPat GhcRn
    forall a. Maybe a
    Nothing [GenLocated SrcSpanAnnA (Pat GhcRn)]
    [LPat GhcRn]
    pats') }

    rnPatAndThen NameMaker
    mk (TuplePat XTuplePat GhcPs
    _ [LPat GhcPs]
    pats Boxity
    boxed)
      = do { [GenLocated SrcSpanAnnA (Pat GhcRn)]
    pats' <- NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen NameMaker
    mk [LPat GhcPs]
    pats
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XTuplePat GhcRn -> [LPat GhcRn] -> Boxity -> Pat GhcRn
    forall p. XTuplePat p -> [LPat p] -> Boxity -> Pat p
    TuplePat NoExtField
    XTuplePat GhcRn
    noExtField [GenLocated SrcSpanAnnA (Pat GhcRn)]
    [LPat GhcRn]
    pats' Boxity
    boxed) }

    rnPatAndThen NameMaker
    mk (SumPat XSumPat GhcPs
    _ LPat GhcPs
    pat Int
    alt Int
    arity)
      = do { GenLocated SrcSpanAnnA (Pat GhcRn)
    pat <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat
           ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XSumPat GhcRn -> LPat GhcRn -> Int -> Int -> Pat GhcRn
    forall p. XSumPat p -> LPat p -> Int -> Int -> Pat p
    SumPat NoExtField
    XSumPat GhcRn
    noExtField GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat Int
    alt Int
    arity)
           }

    -- If a splice has been run already, just rename the result.
    rnPatAndThen NameMaker
    mk (SplicePat XSplicePat GhcPs
    x (HsSpliced XSpliced GhcPs
    x2 ThModFinalizers
    mfs (HsSplicedPat Pat GhcPs
    pat)))
      = XSplicePat GhcRn -> HsSplice GhcRn -> Pat GhcRn
    forall p. XSplicePat p -> HsSplice p -> Pat p
    SplicePat XSplicePat GhcPs
    XSplicePat GhcRn
    x (HsSplice GhcRn -> Pat GhcRn)
    -> (Pat GhcRn -> HsSplice GhcRn) -> Pat GhcRn -> Pat GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . XSpliced GhcRn
    -> ThModFinalizers -> HsSplicedThing GhcRn -> HsSplice GhcRn
    forall id.
    XSpliced id -> ThModFinalizers -> HsSplicedThing id -> HsSplice id
    HsSpliced XSpliced GhcPs
    XSpliced GhcRn
    x2 ThModFinalizers
    mfs (HsSplicedThing GhcRn -> HsSplice GhcRn)
    -> (Pat GhcRn -> HsSplicedThing GhcRn)
    -> Pat GhcRn
    -> HsSplice GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Pat GhcRn -> HsSplicedThing GhcRn
    forall id. Pat id -> HsSplicedThing id
    HsSplicedPat (Pat GhcRn -> Pat GhcRn) -> CpsRn (Pat GhcRn) -> CpsRn (Pat GhcRn)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    mk Pat GhcPs
    pat

    rnPatAndThen NameMaker
    mk (SplicePat XSplicePat GhcPs
    _ HsSplice GhcPs
    splice)
      = do { Either (Pat GhcPs) (Pat GhcRn)
    eith <- RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
    -> CpsRn (Either (Pat GhcPs) (Pat GhcRn))
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
     -> CpsRn (Either (Pat GhcPs) (Pat GhcRn)))
    -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
    -> CpsRn (Either (Pat GhcPs) (Pat GhcRn))
    forall a b. (a -> b) -> a -> b
    $ HsSplice GhcPs -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
    rnSplicePat HsSplice GhcPs
    splice
           ; case Either (Pat GhcPs) (Pat GhcRn)
    eith of   -- See Note [rnSplicePat] in GHC.Rename.Splice
               Left  Pat GhcPs
    not_yet_renamed -> NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
    rnPatAndThen NameMaker
    mk Pat GhcPs
    not_yet_renamed
               Right Pat GhcRn
    already_renamed -> Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Pat GhcRn
    already_renamed }

    --------------------
    rnConPatAndThen :: NameMaker
                    -> LocatedN RdrName    -- the constructor
                    -> HsConPatDetails GhcPs
                    -> CpsRn (Pat GhcRn)

    rnConPatAndThen :: NameMaker
    -> GenLocated (SrcAnn NameAnn) RdrName
    -> HsConPatDetails GhcPs
    -> CpsRn (Pat GhcRn)
    rnConPatAndThen NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    con (PrefixCon [HsPatSigType (NoGhcTc GhcPs)]
    tyargs [LPat GhcPs]
    pats)
      = do  { LocatedN Name
    con' <- GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    lookupConCps GenLocated (SrcAnn NameAnn) RdrName
    con
            ; IOEnv (Env TcGblEnv TcLclEnv) () -> CpsRn ()
    forall a. RnM a -> CpsRn a
    liftCps IOEnv (Env TcGblEnv TcLclEnv) ()
    check_lang_exts
            ; [HsPatSigType GhcRn]
    tyargs' <- [HsPatSigType GhcPs]
    -> (HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn))
    -> CpsRn [HsPatSigType GhcRn]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [HsPatSigType (NoGhcTc GhcPs)]
    [HsPatSigType GhcPs]
    tyargs ((HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn))
     -> CpsRn [HsPatSigType GhcRn])
    -> (HsPatSigType GhcPs -> CpsRn (HsPatSigType GhcRn))
    -> CpsRn [HsPatSigType GhcRn]
    forall a b. (a -> b) -> a -> b
    $ \HsPatSigType GhcPs
    t ->
                (forall r.
     (HsPatSigType GhcRn -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn (HsPatSigType GhcRn)
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    liftCpsWithCont ((forall r.
      (HsPatSigType GhcRn -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
     -> CpsRn (HsPatSigType GhcRn))
    -> (forall r.
        (HsPatSigType GhcRn -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn (HsPatSigType GhcRn)
    forall a b. (a -> b) -> a -> b
    $ HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (r, FreeVars))
    -> RnM (r, FreeVars)
    forall r.
    HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (r, FreeVars))
    -> RnM (r, FreeVars)
    rnHsPatSigTypeBindingVars HsDocContext
    HsTypeCtx HsPatSigType GhcPs
    t
            ; [GenLocated SrcSpanAnnA (Pat GhcRn)]
    pats' <- NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn]
    rnLPatsAndThen NameMaker
    mk [LPat GhcPs]
    pats
            ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Pat GhcRn -> CpsRn (Pat GhcRn)) -> Pat GhcRn -> CpsRn (Pat GhcRn)
    forall a b. (a -> b) -> a -> b
    $ ConPat
                { pat_con_ext :: XConPat GhcRn
    pat_con_ext = NoExtField
    XConPat GhcRn
    noExtField
                , pat_con :: XRec GhcRn (ConLikeP GhcRn)
    pat_con = LocatedN Name
    XRec GhcRn (ConLikeP GhcRn)
    con'
                , pat_args :: HsConPatDetails GhcRn
    pat_args = [HsPatSigType GhcRn]
    -> [GenLocated SrcSpanAnnA (Pat GhcRn)]
    -> HsConDetails
         (HsPatSigType GhcRn)
         (GenLocated SrcSpanAnnA (Pat GhcRn))
         (HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn)))
    forall tyarg arg rec.
    [tyarg] -> [arg] -> HsConDetails tyarg arg rec
    PrefixCon [HsPatSigType GhcRn]
    tyargs' [GenLocated SrcSpanAnnA (Pat GhcRn)]
    pats'
                }
            }
      where
        check_lang_exts :: RnM ()
        check_lang_exts :: IOEnv (Env TcGblEnv TcLclEnv) ()
    check_lang_exts = do
          Bool
    scoped_tyvars <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.ScopedTypeVariables
          Bool
    type_app      <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.TypeApplications
          Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Bool
    scoped_tyvars Bool -> Bool -> Bool
    && Bool
    type_app) (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
            case [HsPatSigType GhcPs] -> Maybe (HsPatSigType GhcPs)
    forall a. [a] -> Maybe a
    listToMaybe [HsPatSigType (NoGhcTc GhcPs)]
    [HsPatSigType GhcPs]
    tyargs of
              Maybe (HsPatSigType GhcPs)
    Nothing    -> () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
              Just HsPatSigType GhcPs
    tyarg -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $
                SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Illegal visible type application in a pattern:"
                        SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Char -> SDoc
    char Char
    '@' SDoc -> SDoc -> SDoc
    <> HsPatSigType GhcPs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsPatSigType GhcPs
    tyarg))
                   Int
    2 (String -> SDoc
    text String
    "Both ScopedTypeVariables and TypeApplications are"
                        SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "required to use this feature")

    rnConPatAndThen NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    con (InfixCon LPat GhcPs
    pat1 LPat GhcPs
    pat2)
      = do  { LocatedN Name
    con' <- GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    lookupConCps GenLocated (SrcAnn NameAnn) RdrName
    con
            ; GenLocated SrcSpanAnnA (Pat GhcRn)
    pat1' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat1
            ; GenLocated SrcSpanAnnA (Pat GhcRn)
    pat2' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen NameMaker
    mk LPat GhcPs
    pat2
            ; Fixity
    fixity <- RnM Fixity -> CpsRn Fixity
    forall a. RnM a -> CpsRn a
    liftCps (RnM Fixity -> CpsRn Fixity) -> RnM Fixity -> CpsRn Fixity
    forall a b. (a -> b) -> a -> b
    $ Name -> RnM Fixity
    lookupFixityRn (LocatedN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LocatedN Name
    con')
            ; RnM (Pat GhcRn) -> CpsRn (Pat GhcRn)
    forall a. RnM a -> CpsRn a
    liftCps (RnM (Pat GhcRn) -> CpsRn (Pat GhcRn))
    -> RnM (Pat GhcRn) -> CpsRn (Pat GhcRn)
    forall a b. (a -> b) -> a -> b
    $ LocatedN Name
    -> Fixity -> LPat GhcRn -> LPat GhcRn -> RnM (Pat GhcRn)
    mkConOpPatRn LocatedN Name
    con' Fixity
    fixity GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat1' GenLocated SrcSpanAnnA (Pat GhcRn)
    LPat GhcRn
    pat2' }

    rnConPatAndThen NameMaker
    mk GenLocated (SrcAnn NameAnn) RdrName
    con (RecCon HsRecFields GhcPs (LPat GhcPs)
    rpats)
      = do  { LocatedN Name
    con' <- GenLocated (SrcAnn NameAnn) RdrName -> CpsRn (LocatedN Name)
    lookupConCps GenLocated (SrcAnn NameAnn) RdrName
    con
            ; HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    rpats' <- NameMaker
    -> LocatedN Name
    -> HsRecFields GhcPs (LPat GhcPs)
    -> CpsRn (HsRecFields GhcRn (LPat GhcRn))
    rnHsRecPatsAndThen NameMaker
    mk LocatedN Name
    con' HsRecFields GhcPs (LPat GhcPs)
    rpats
            ; Pat GhcRn -> CpsRn (Pat GhcRn)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Pat GhcRn -> CpsRn (Pat GhcRn)) -> Pat GhcRn -> CpsRn (Pat GhcRn)
    forall a b. (a -> b) -> a -> b
    $ ConPat
                { pat_con_ext :: XConPat GhcRn
    pat_con_ext = NoExtField
    XConPat GhcRn
    noExtField
                , pat_con :: XRec GhcRn (ConLikeP GhcRn)
    pat_con = LocatedN Name
    XRec GhcRn (ConLikeP GhcRn)
    con'
                , pat_args :: HsConPatDetails GhcRn
    pat_args = HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    -> HsConDetails
         (HsPatSigType GhcRn)
         (GenLocated SrcSpanAnnA (Pat GhcRn))
         (HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn)))
    forall tyarg arg rec. rec -> HsConDetails tyarg arg rec
    RecCon HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    rpats'
                }
            }

    checkUnusedRecordWildcardCps :: SrcSpan -> Maybe [Name] -> CpsRn ()
    checkUnusedRecordWildcardCps :: SrcSpan -> Maybe [Name] -> CpsRn ()
    checkUnusedRecordWildcardCps SrcSpan
    loc Maybe [Name]
    dotdot_names =
      (forall r. (() -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn ()
    forall b.
    (forall r. (b -> RnM (r, FreeVars)) -> RnM (r, FreeVars))
    -> CpsRn b
    CpsRn (\() -> RnM (r, FreeVars)
    thing -> do
                        (r
    r, FreeVars
    fvs) <- () -> RnM (r, FreeVars)
    thing ()
                        SrcSpan
    -> FreeVars -> Maybe [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkUnusedRecordWildcard SrcSpan
    loc FreeVars
    fvs Maybe [Name]
    dotdot_names
                        (r, FreeVars) -> RnM (r, FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (r
    r, FreeVars
    fvs) )
    --------------------
    rnHsRecPatsAndThen :: NameMaker
                       -> LocatedN Name      -- Constructor
                       -> HsRecFields GhcPs (LPat GhcPs)
                       -> CpsRn (HsRecFields GhcRn (LPat GhcRn))
    rnHsRecPatsAndThen :: NameMaker
    -> LocatedN Name
    -> HsRecFields GhcPs (LPat GhcPs)
    -> CpsRn (HsRecFields GhcRn (LPat GhcRn))
    rnHsRecPatsAndThen NameMaker
    mk (L SrcAnn NameAnn
    _ Name
    con)
         hs_rec_fields :: HsRecFields GhcPs (LPat GhcPs)
    hs_rec_fields@(HsRecFields { rec_dotdot :: forall p arg. HsRecFields p arg -> Maybe (Located Int)
    rec_dotdot = Maybe (Located Int)
    dd })
      = do { [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))]
    flds <- RnM
      ([GenLocated
          SrcSpanAnnA
          (HsRecField'
             (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))],
       FreeVars)
    -> CpsRn
         [GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))]
    forall a. RnM (a, FreeVars) -> CpsRn a
    liftCpsFV (RnM
       ([GenLocated
           SrcSpanAnnA
           (HsRecField'
              (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))],
        FreeVars)
     -> CpsRn
          [GenLocated
             SrcSpanAnnA
             (HsRecField'
                (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))])
    -> RnM
         ([GenLocated
             SrcSpanAnnA
             (HsRecField'
                (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))],
          FreeVars)
    -> CpsRn
         [GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))]
    forall a b. (a -> b) -> a -> b
    $ HsRecFieldContext
    -> (SrcSpan -> RdrName -> Pat GhcPs)
    -> HsRecFields GhcPs (GenLocated SrcSpanAnnA (Pat GhcPs))
    -> RnM
         ([LHsRecField GhcRn (GenLocated SrcSpanAnnA (Pat GhcPs))],
          FreeVars)
    forall arg.
    HsRecFieldContext
    -> (SrcSpan -> RdrName -> arg)
    -> HsRecFields GhcPs (LocatedA arg)
    -> RnM ([LHsRecField GhcRn (LocatedA arg)], FreeVars)
    rnHsRecFields (Name -> HsRecFieldContext
    HsRecFieldPat Name
    con) SrcSpan -> RdrName -> Pat GhcPs
    forall {p} {ann}.
    (XVarPat p ~ NoExtField,
     XRec p (IdP p) ~ GenLocated (SrcAnn ann) (IdP p)) =>
    SrcSpan -> IdP p -> Pat p
    mkVarPat
                                                HsRecFields GhcPs (GenLocated SrcSpanAnnA (Pat GhcPs))
    HsRecFields GhcPs (LPat GhcPs)
    hs_rec_fields
           ; [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))]
    flds' <- ((GenLocated
        SrcSpanAnnA
        (HsRecField'
           (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))),
      Int)
     -> CpsRn
          (GenLocated
             SrcSpanAnnA
             (HsRecField'
                (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))))
    -> [(GenLocated
           SrcSpanAnnA
           (HsRecField'
              (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))),
         Int)]
    -> CpsRn
         [GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))),
     Int)
    -> CpsRn
         (GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn))))
    rn_field ([GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))]
    flds [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs)))]
    -> [Int]
    -> [(GenLocated
           SrcSpanAnnA
           (HsRecField'
              (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))),
         Int)]
    forall a b. [a] -> [b] -> [(a, b)]
    `zip` [Int
    1..])
           ; Maybe [Name] -> CpsRn ()
    check_unused_wildcard ([GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LPat GhcRn))]
    -> Located Int -> [IdP GhcRn]
    forall {p} {l} {id} {l}.
    CollectPass p =>
    [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    -> GenLocated l Int -> [IdP p]
    implicit_binders [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))]
    [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LPat GhcRn))]
    flds' (Located Int -> [Name]) -> Maybe (Located Int) -> Maybe [Name]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Located Int)
    dd)
           ; HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))
    -> CpsRn (HsRecFields GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn)))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (HsRecFields { rec_flds :: [LHsRecField GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))]
    rec_flds = [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))]
    [LHsRecField GhcRn (GenLocated SrcSpanAnnA (Pat GhcRn))]
    flds', rec_dotdot :: Maybe (Located Int)
    rec_dotdot = Maybe (Located Int)
    dd }) }
      where
        mkVarPat :: SrcSpan -> IdP p -> Pat p
    mkVarPat SrcSpan
    l IdP p
    n = XVarPat p -> XRec p (IdP p) -> Pat p
    forall p. XVarPat p -> LIdP p -> Pat p
    VarPat NoExtField
    XVarPat p
    noExtField (SrcAnn ann -> IdP p -> GenLocated (SrcAnn ann) (IdP p)
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn ann
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    l) IdP p
    n)
        rn_field :: (GenLocated
       SrcSpanAnnA
       (HsRecField'
          (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))),
     Int)
    -> CpsRn
         (GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn))))
    rn_field (L SrcSpanAnnA
    l HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))
    fld, Int
    n') =
          do { GenLocated SrcSpanAnnA (Pat GhcRn)
    arg' <- NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn)
    rnLPatAndThen (Maybe (Located Int) -> NameMaker -> Int -> NameMaker
    forall {a} {l}.
    Ord a =>
    Maybe (GenLocated l a) -> NameMaker -> a -> NameMaker
    nested_mk Maybe (Located Int)
    dd NameMaker
    mk Int
    n') (HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))
    -> GenLocated SrcSpanAnnA (Pat GhcPs)
    forall id arg. HsRecField' id arg -> arg
    hsRecFieldArg HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))
    fld)
             ; GenLocated
      SrcSpanAnnA
      (HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))
    -> CpsRn
         (GenLocated
            SrcSpanAnnA
            (HsRecField'
               (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn))))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcSpanAnnA
    -> HsRecField'
         (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn))
    -> GenLocated
         SrcSpanAnnA
         (HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcRn)))
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    l (HsRecField' (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (Pat GhcPs))
    fld { hsRecFieldArg :: GenLocated SrcSpanAnnA (Pat GhcRn)
    hsRecFieldArg = GenLocated SrcSpanAnnA (Pat GhcRn)
    arg' })) }

        loc :: SrcSpan
    loc = SrcSpan
    -> (Located Int -> SrcSpan) -> Maybe (Located Int) -> SrcSpan
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe SrcSpan
    noSrcSpan Located Int -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc Maybe (Located Int)
    dd

        -- Get the arguments of the implicit binders
        implicit_binders :: [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    -> GenLocated l Int -> [IdP p]
    implicit_binders [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    fs (GenLocated l Int -> Int
    forall l e. GenLocated l e -> e
    unLoc -> Int
    n) = CollectFlag p -> [XRec p (Pat p)] -> [IdP p]
    forall p. CollectPass p => CollectFlag p -> [LPat p] -> [IdP p]
    collectPatsBinders CollectFlag p
    forall p. CollectFlag p
    CollNoDictBinders [XRec p (Pat p)]
    implicit_pats
          where
            implicit_pats :: [XRec p (Pat p)]
    implicit_pats = (GenLocated l (HsRecField' id (XRec p (Pat p))) -> XRec p (Pat p))
    -> [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    -> [XRec p (Pat p)]
    forall a b. (a -> b) -> [a] -> [b]
    map (HsRecField' id (XRec p (Pat p)) -> XRec p (Pat p)
    forall id arg. HsRecField' id arg -> arg
    hsRecFieldArg (HsRecField' id (XRec p (Pat p)) -> XRec p (Pat p))
    -> (GenLocated l (HsRecField' id (XRec p (Pat p)))
        -> HsRecField' id (XRec p (Pat p)))
    -> GenLocated l (HsRecField' id (XRec p (Pat p)))
    -> XRec p (Pat p)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated l (HsRecField' id (XRec p (Pat p)))
    -> HsRecField' id (XRec p (Pat p))
    forall l e. GenLocated l e -> e
    unLoc) (Int
    -> [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    -> [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    forall a. Int -> [a] -> [a]
    drop Int
    n [GenLocated l (HsRecField' id (XRec p (Pat p)))]
    fs)

        -- Don't warn for let P{..} = ... in ...
        check_unused_wildcard :: Maybe [Name] -> CpsRn ()
    check_unused_wildcard = case NameMaker
    mk of
                                  LetMk{} -> CpsRn () -> Maybe [Name] -> CpsRn ()
    forall a b. a -> b -> a
    const (() -> CpsRn ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ())
                                  LamMk{} -> SrcSpan -> Maybe [Name] -> CpsRn ()
    checkUnusedRecordWildcardCps SrcSpan
    loc

            -- Suppress unused-match reporting for fields introduced by ".."
        nested_mk :: Maybe (GenLocated l a) -> NameMaker -> a -> NameMaker
    nested_mk Maybe (GenLocated l a)
    Nothing  NameMaker
    mk                    a
    _  = NameMaker
    mk
        nested_mk (Just GenLocated l a
    _) mk :: NameMaker
    mk@(LetMk {})         a
    _  = NameMaker
    mk
        nested_mk (Just (GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc -> a
    n)) (LamMk Bool
    report_unused) a
    n'
          = Bool -> NameMaker
    LamMk (Bool
    report_unused Bool -> Bool -> Bool
    && (a
    n' a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    <= a
    n))

    {-
    ************************************************************************
    *                                                                      *
            Record fields
    *                                                                      *
    ************************************************************************
    -}

    data HsRecFieldContext
      = HsRecFieldCon Name
      | HsRecFieldPat Name
      | HsRecFieldUpd

    rnHsRecFields
        :: forall arg.
           HsRecFieldContext
        -> (SrcSpan -> RdrName -> arg)
             -- When punning, use this to build a new field
        -> HsRecFields GhcPs (LocatedA arg)
        -> RnM ([LHsRecField GhcRn (LocatedA arg)], FreeVars)

    -- This surprisingly complicated pass
    --   a) looks up the field name (possibly using disambiguation)
    --   b) fills in puns and dot-dot stuff
    -- When we've finished, we've renamed the LHS, but not the RHS,
    -- of each x=e binding
    --
    -- This is used for record construction and pattern-matching, but not updates.

    rnHsRecFields :: forall arg.
    HsRecFieldContext
    -> (SrcSpan -> RdrName -> arg)
    -> HsRecFields GhcPs (LocatedA arg)
    -> RnM ([LHsRecField GhcRn (LocatedA arg)], FreeVars)
    rnHsRecFields HsRecFieldContext
    ctxt SrcSpan -> RdrName -> arg
    mk_arg (HsRecFields { rec_flds :: forall p arg. HsRecFields p arg -> [LHsRecField p arg]
    rec_flds = [LHsRecField GhcPs (LocatedA arg)]
    flds, rec_dotdot :: forall p arg. HsRecFields p arg -> Maybe (Located Int)
    rec_dotdot = Maybe (Located Int)
    dotdot })
      = do { Bool
    pun_ok      <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RecordPuns
           ; Bool
    disambig_ok <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DisambiguateRecordFields
           ; let parent :: Maybe Name
    parent = Bool -> Maybe ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard Bool
    disambig_ok Maybe () -> Maybe Name -> Maybe Name
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Maybe Name
    mb_con
           ; [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    flds1  <- (GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcPs) (LocatedA arg))
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated
             SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))))
    -> [GenLocated
          SrcSpanAnnA (HsRecField' (FieldOcc GhcPs) (LocatedA arg))]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated
            SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Bool
    -> Maybe Name
    -> LHsRecField GhcPs (LocatedA arg)
    -> RnM (LHsRecField GhcRn (LocatedA arg))
    rn_fld Bool
    pun_ok Maybe Name
    parent) [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcPs) (LocatedA arg))]
    [LHsRecField GhcPs (LocatedA arg)]
    flds
           ; (NonEmpty RdrName -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [NonEmpty RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> (NonEmpty RdrName -> SDoc)
    -> NonEmpty RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsRecFieldContext -> NonEmpty RdrName -> SDoc
    dupFieldErr HsRecFieldContext
    ctxt) [NonEmpty RdrName]
    dup_flds
           ; [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    dotdot_flds <- Maybe (Located Int)
    -> Maybe Name
    -> [LHsRecField GhcRn (LocatedA arg)]
    -> RnM [LHsRecField GhcRn (LocatedA arg)]
    rn_dotdot Maybe (Located Int)
    dotdot Maybe Name
    mb_con [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    [LHsRecField GhcRn (LocatedA arg)]
    flds1
           ; let all_flds :: [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    all_flds | [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    dotdot_flds = [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    flds1
                          | Bool
    otherwise        = [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    flds1 [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    -> [GenLocated
          SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    -> [GenLocated
          SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    forall a. [a] -> [a] -> [a]
    ++ [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    dotdot_flds
           ; ([GenLocated
        SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))],
     FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         ([GenLocated
             SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))],
          FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    all_flds, [Name] -> FreeVars
    mkFVs ([LHsRecField GhcRn (LocatedA arg)] -> [Name]
    forall arg. [LHsRecField GhcRn arg] -> [Name]
    getFieldIds [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    [LHsRecField GhcRn (LocatedA arg)]
    all_flds)) }
      where
        mb_con :: Maybe Name
    mb_con = case HsRecFieldContext
    ctxt of
                    HsRecFieldCon Name
    con  -> Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    con
                    HsRecFieldPat Name
    con  -> Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    con
                    HsRecFieldContext
    _ {- update -}     -> Maybe Name
    forall a. Maybe a
    Nothing

        rn_fld :: Bool -> Maybe Name -> LHsRecField GhcPs (LocatedA arg)
               -> RnM (LHsRecField GhcRn (LocatedA arg))
        rn_fld :: Bool
    -> Maybe Name
    -> LHsRecField GhcPs (LocatedA arg)
    -> RnM (LHsRecField GhcRn (LocatedA arg))
    rn_fld Bool
    pun_ok Maybe Name
    parent (L SrcSpanAnnA
    l
                               (HsRecField
                                  { hsRecFieldLbl :: forall id arg. HsRecField' id arg -> Located id
    hsRecFieldLbl =
                                      (L SrcSpan
    loc (FieldOcc XCFieldOcc GhcPs
    _ (L SrcAnn NameAnn
    ll RdrName
    lbl)))
                                  , hsRecFieldArg :: forall id arg. HsRecField' id arg -> arg
    hsRecFieldArg = LocatedA arg
    arg
                                  , hsRecPun :: forall id arg. HsRecField' id arg -> Bool
    hsRecPun      = Bool
    pun }))
          = do { Name
    sel <- SrcSpan -> RnM Name -> RnM Name
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan SrcSpan
    loc (RnM Name -> RnM Name) -> RnM Name -> RnM Name
    forall a b. (a -> b) -> a -> b
    $ Maybe Name -> RdrName -> RnM Name
    lookupRecFieldOcc Maybe Name
    parent RdrName
    lbl
               ; LocatedA arg
    arg' <- if Bool
    pun
                         then do { Bool -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkErr Bool
    pun_ok (Located RdrName -> SDoc
    badPun (SrcSpan -> RdrName -> Located RdrName
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    loc RdrName
    lbl))
                                   -- Discard any module qualifier (#11662)
                                 ; let arg_rdr :: RdrName
    arg_rdr = OccName -> RdrName
    mkRdrUnqual (RdrName -> OccName
    rdrNameOcc RdrName
    lbl)
                                 ; LocatedA arg -> IOEnv (Env TcGblEnv TcLclEnv) (LocatedA arg)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcSpanAnnA -> arg -> LocatedA arg
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcSpanAnnA
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) (SrcSpan -> RdrName -> arg
    mk_arg SrcSpan
    loc RdrName
    arg_rdr)) }
                         else LocatedA arg -> IOEnv (Env TcGblEnv TcLclEnv) (LocatedA arg)
    forall (m :: * -> *) a. Monad m => a -> m a
    return LocatedA arg
    arg
               ; GenLocated
      SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated
            SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg)))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcSpanAnnA
    -> HsRecField' (FieldOcc GhcRn) (LocatedA arg)
    -> GenLocated
         SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    l (HsRecField
                                 { hsRecFieldAnn :: XHsRecField (FieldOcc GhcRn)
    hsRecFieldAnn = XHsRecField (FieldOcc GhcRn)
    forall a. EpAnn a
    noAnn
                                 , hsRecFieldLbl :: Located (FieldOcc GhcRn)
    hsRecFieldLbl = (SrcSpan -> FieldOcc GhcRn -> Located (FieldOcc GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    loc (XCFieldOcc GhcRn
    -> GenLocated (SrcAnn NameAnn) RdrName -> FieldOcc GhcRn
    forall pass.
    XCFieldOcc pass
    -> GenLocated (SrcAnn NameAnn) RdrName -> FieldOcc pass
    FieldOcc Name
    XCFieldOcc GhcRn
    sel (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L SrcAnn NameAnn
    ll RdrName
    lbl)))
                                 , hsRecFieldArg :: LocatedA arg
    hsRecFieldArg = LocatedA arg
    arg'
                                 , hsRecPun :: Bool
    hsRecPun      = Bool
    pun })) }

        rn_dotdot :: Maybe (Located Int)      -- See Note [DotDot fields] in GHC.Hs.Pat
                  -> Maybe Name -- The constructor (Nothing for an
                                    --    out of scope constructor)
                  -> [LHsRecField GhcRn (LocatedA arg)] -- Explicit fields
                  -> RnM ([LHsRecField GhcRn (LocatedA arg)])   -- Field Labels we need to fill in
        rn_dotdot :: Maybe (Located Int)
    -> Maybe Name
    -> [LHsRecField GhcRn (LocatedA arg)]
    -> RnM [LHsRecField GhcRn (LocatedA arg)]
    rn_dotdot (Just (L SrcSpan
    loc Int
    n)) (Just Name
    con) [LHsRecField GhcRn (LocatedA arg)]
    flds -- ".." on record construction / pat match
          | Bool -> Bool
    not (Name -> Bool
    isUnboundName Name
    con) -- This test is because if the constructor
                                    -- isn't in scope the constructor lookup will add
                                    -- an error but still return an unbound name. We
                                    -- don't want that to screw up the dot-dot fill-in stuff.
          = ASSERT( flds `lengthIs` n )
            do { Bool
    dd_flag <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RecordWildCards
               ; Bool -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkErr Bool
    dd_flag (HsRecFieldContext -> SDoc
    needFlagDotDot HsRecFieldContext
    ctxt)
               ; (GlobalRdrEnv
    rdr_env, LocalRdrEnv
    lcl_env) <- TcRn (GlobalRdrEnv, LocalRdrEnv)
    getRdrEnvs
               ; [FieldLabel]
    con_fields <- Name -> RnM [FieldLabel]
    lookupConstructorFields Name
    con
               ; Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when ([FieldLabel] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [FieldLabel]
    con_fields) (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (Name -> SDoc
    badDotDotCon Name
    con))
               ; let present_flds :: OccSet
    present_flds = [OccName] -> OccSet
    mkOccSet ([OccName] -> OccSet) -> [OccName] -> OccSet
    forall a b. (a -> b) -> a -> b
    $ (RdrName -> OccName) -> [RdrName] -> [OccName]
    forall a b. (a -> b) -> [a] -> [b]
    map RdrName -> OccName
    rdrNameOcc ([LHsRecField GhcRn (LocatedA arg)] -> [RdrName]
    forall p arg. UnXRec p => [LHsRecField p arg] -> [RdrName]
    getFieldLbls [LHsRecField GhcRn (LocatedA arg)]
    flds)

                       -- For constructor uses (but not patterns)
                       -- the arg should be in scope locally;
                       -- i.e. not top level or imported
                       -- Eg.  data R = R { x,y :: Int }
                       --      f x = R { .. }   -- Should expand to R {x=x}, not R{x=x,y=y}
                     arg_in_scope :: OccName -> Bool
    arg_in_scope OccName
    lbl = OccName -> RdrName
    mkRdrUnqual OccName
    lbl RdrName -> LocalRdrEnv -> Bool
    `elemLocalRdrEnv` LocalRdrEnv
    lcl_env

                     ([FieldLabel]
    dot_dot_fields, [GlobalRdrElt]
    dot_dot_gres)
                            = [(FieldLabel, GlobalRdrElt)] -> ([FieldLabel], [GlobalRdrElt])
    forall a b. [(a, b)] -> ([a], [b])
    unzip [ (FieldLabel
    fl, GlobalRdrElt
    gre)
                                    | FieldLabel
    fl <- [FieldLabel]
    con_fields
                                    , let lbl :: OccName
    lbl = FastString -> OccName
    mkVarOccFS (FieldLabel -> FastString
    flLabel FieldLabel
    fl)
                                    , Bool -> Bool
    not (OccName
    lbl OccName -> OccSet -> Bool
    `elemOccSet` OccSet
    present_flds)
                                    , Just GlobalRdrElt
    gre <- [GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
    lookupGRE_FieldLabel GlobalRdrEnv
    rdr_env FieldLabel
    fl]
                                                  -- Check selector is in scope
                                    , case HsRecFieldContext
    ctxt of
                                        HsRecFieldCon {} -> OccName -> Bool
    arg_in_scope OccName
    lbl
                                        HsRecFieldContext
    _other           -> Bool
    True ]

               ; [GlobalRdrElt] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addUsedGREs [GlobalRdrElt]
    dot_dot_gres
               ; let locn :: SrcSpanAnnA
    locn = SrcSpan -> SrcSpanAnnA
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc
               ; [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated
            SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [ SrcSpanAnnA
    -> HsRecField' (FieldOcc GhcRn) (LocatedA arg)
    -> GenLocated
         SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcSpanAnnA
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) (HsRecField
                            { hsRecFieldAnn :: XHsRecField (FieldOcc GhcRn)
    hsRecFieldAnn = XHsRecField (FieldOcc GhcRn)
    forall a. EpAnn a
    noAnn
                            , hsRecFieldLbl :: Located (FieldOcc GhcRn)
    hsRecFieldLbl
                               = SrcSpan -> FieldOcc GhcRn -> Located (FieldOcc GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    loc (XCFieldOcc GhcRn
    -> GenLocated (SrcAnn NameAnn) RdrName -> FieldOcc GhcRn
    forall pass.
    XCFieldOcc pass
    -> GenLocated (SrcAnn NameAnn) RdrName -> FieldOcc pass
    FieldOcc Name
    XCFieldOcc GhcRn
    sel (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) RdrName
    arg_rdr))
                            , hsRecFieldArg :: LocatedA arg
    hsRecFieldArg = SrcSpanAnnA -> arg -> LocatedA arg
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    locn (SrcSpan -> RdrName -> arg
    mk_arg SrcSpan
    loc RdrName
    arg_rdr)
                            , hsRecPun :: Bool
    hsRecPun      = Bool
    False })
                        | FieldLabel
    fl <- [FieldLabel]
    dot_dot_fields
                        , let sel :: Name
    sel     = FieldLabel -> Name
    flSelector FieldLabel
    fl
                        , let arg_rdr :: RdrName
    arg_rdr = FastString -> RdrName
    mkVarUnqual (FieldLabel -> FastString
    flLabel FieldLabel
    fl) ] }

        rn_dotdot Maybe (Located Int)
    _dotdot Maybe Name
    _mb_con [LHsRecField GhcRn (LocatedA arg)]
    _flds
          = [GenLocated
       SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated
            SrcSpanAnnA (HsRecField' (FieldOcc GhcRn) (LocatedA arg))]
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
          -- _dotdot = Nothing => No ".." at all
          -- _mb_con = Nothing => Record update
          -- _mb_con = Just unbound => Out of scope data constructor

        dup_flds :: [NE.NonEmpty RdrName]
            -- Each list represents a RdrName that occurred more than once
            -- (the list contains all occurrences)
            -- Each list in dup_fields is non-empty
        ([RdrName]
    _, [NonEmpty RdrName]
    dup_flds) = (RdrName -> RdrName -> Ordering)
    -> [RdrName] -> ([RdrName], [NonEmpty RdrName])
    forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
    removeDups RdrName -> RdrName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ([LHsRecField GhcPs (LocatedA arg)] -> [RdrName]
    forall p arg. UnXRec p => [LHsRecField p arg] -> [RdrName]
    getFieldLbls [LHsRecField GhcPs (LocatedA arg)]
    flds)

    -- NB: Consider this:
    --      module Foo where { data R = R { fld :: Int } }
    --      module Odd where { import Foo; fld x = x { fld = 3 } }
    -- Arguably this should work, because the reference to 'fld' is
    -- unambiguous because there is only one field id 'fld' in scope.
    -- But currently it's rejected.

    rnHsRecUpdFields
        :: [LHsRecUpdField GhcPs]
        -> RnM ([LHsRecUpdField GhcRn], FreeVars)
    rnHsRecUpdFields :: [LHsRecUpdField GhcPs] -> RnM ([LHsRecUpdField GhcRn], FreeVars)
    rnHsRecUpdFields [LHsRecUpdField GhcPs]
    flds
      = do { Bool
    pun_ok        <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.RecordPuns
           ; DuplicateRecordFields
    dup_fields_ok <- DynFlags -> DuplicateRecordFields
    xopt_DuplicateRecordFields (DynFlags -> DuplicateRecordFields)
    -> IOEnv (Env TcGblEnv TcLclEnv) DynFlags
    -> IOEnv (Env TcGblEnv TcLclEnv) DuplicateRecordFields
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IOEnv (Env TcGblEnv TcLclEnv) DynFlags
    forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
           ; ([GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
    flds1, [FreeVars]
    fvss) <- (GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated
             SrcSpanAnnA
             (HsRecField'
                (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
           FreeVars))
    -> [GenLocated
          SrcSpanAnnA
          (HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         ([GenLocated
             SrcSpanAnnA
             (HsRecField'
                (AmbiguousFieldOcc GhcRn)
                (GenLocated SrcSpanAnnA (HsExpr GhcRn)))],
          [FreeVars])
    forall (m :: * -> *) a b c.
    Applicative m =>
    (a -> m (b, c)) -> [a] -> m ([b], [c])
    mapAndUnzipM (Bool
    -> DuplicateRecordFields
    -> LHsRecUpdField GhcPs
    -> RnM (LHsRecUpdField GhcRn, FreeVars)
    rn_fld Bool
    pun_ok DuplicateRecordFields
    dup_fields_ok) [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    [LHsRecUpdField GhcPs]
    flds
           ; (NonEmpty RdrName -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> [NonEmpty RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr (SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> (NonEmpty RdrName -> SDoc)
    -> NonEmpty RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsRecFieldContext -> NonEmpty RdrName -> SDoc
    dupFieldErr HsRecFieldContext
    HsRecFieldUpd) [NonEmpty RdrName]
    dup_flds

           -- Check for an empty record update  e {}
           -- NB: don't complain about e { .. }, because rn_dotdot has done that already
           ; Bool
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when ([GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    [LHsRecUpdField GhcPs]
    flds) (IOEnv (Env TcGblEnv TcLclEnv) ()
     -> IOEnv (Env TcGblEnv TcLclEnv) ())
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall a b. (a -> b) -> a -> b
    $ SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    addErr SDoc
    emptyUpdateErr

           ; ([GenLocated
        SrcSpanAnnA
        (HsRecField'
           (AmbiguousFieldOcc GhcRn)
           (GenLocated SrcSpanAnnA (HsExpr GhcRn)))],
     FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         ([GenLocated
             SrcSpanAnnA
             (HsRecField'
                (AmbiguousFieldOcc GhcRn)
                (GenLocated SrcSpanAnnA (HsExpr GhcRn)))],
          FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
    flds1, [FreeVars] -> FreeVars
    plusFVs [FreeVars]
    fvss) }
      where
        rn_fld :: Bool -> DuplicateRecordFields -> LHsRecUpdField GhcPs
               -> RnM (LHsRecUpdField GhcRn, FreeVars)
        rn_fld :: Bool
    -> DuplicateRecordFields
    -> LHsRecUpdField GhcPs
    -> RnM (LHsRecUpdField GhcRn, FreeVars)
    rn_fld Bool
    pun_ok DuplicateRecordFields
    dup_fields_ok (L SrcSpanAnnA
    l (HsRecField { hsRecFieldLbl :: forall id arg. HsRecField' id arg -> Located id
    hsRecFieldLbl = L SrcSpan
    loc AmbiguousFieldOcc GhcPs
    f
                                                   , hsRecFieldArg :: forall id arg. HsRecField' id arg -> arg
    hsRecFieldArg = GenLocated SrcSpanAnnA (HsExpr GhcPs)
    arg
                                                   , hsRecPun :: forall id arg. HsRecField' id arg -> Bool
    hsRecPun      = Bool
    pun }))
          = do { let lbl :: RdrName
    lbl = AmbiguousFieldOcc GhcPs -> RdrName
    forall (p :: Pass). AmbiguousFieldOcc (GhcPass p) -> RdrName
    rdrNameAmbiguousFieldOcc AmbiguousFieldOcc GhcPs
    f
               ; AmbiguousResult
    mb_sel <- SrcSpan -> TcRn AmbiguousResult -> TcRn AmbiguousResult
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan SrcSpan
    loc (TcRn AmbiguousResult -> TcRn AmbiguousResult)
    -> TcRn AmbiguousResult -> TcRn AmbiguousResult
    forall a b. (a -> b) -> a -> b
    $
                          -- Defer renaming of overloaded fields to the typechecker
                          -- See Note [Disambiguating record fields] in GHC.Tc.Gen.Head
                          DuplicateRecordFields -> RdrName -> TcRn AmbiguousResult
    lookupRecFieldOcc_update DuplicateRecordFields
    dup_fields_ok RdrName
    lbl
               ; GenLocated SrcSpanAnnA (HsExpr GhcPs)
    arg' <- if Bool
    pun
                         then do { Bool -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkErr Bool
    pun_ok (Located RdrName -> SDoc
    badPun (SrcSpan -> RdrName -> Located RdrName
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    loc RdrName
    lbl))
                                   -- Discard any module qualifier (#11662)
                                 ; let arg_rdr :: RdrName
    arg_rdr = OccName -> RdrName
    mkRdrUnqual (RdrName -> OccName
    rdrNameOcc RdrName
    lbl)
                                 ; GenLocated SrcSpanAnnA (HsExpr GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcSpanAnnA
    -> HsExpr GhcPs -> GenLocated SrcSpanAnnA (HsExpr GhcPs)
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcSpanAnnA
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) (XVar GhcPs -> XRec GhcPs (IdP GhcPs) -> HsExpr GhcPs
    forall p. XVar p -> LIdP p -> HsExpr p
    HsVar NoExtField
    XVar GhcPs
    noExtField
                                                  (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) RdrName
    arg_rdr))) }
                         else GenLocated SrcSpanAnnA (HsExpr GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
    forall (m :: * -> *) a. Monad m => a -> m a
    return GenLocated SrcSpanAnnA (HsExpr GhcPs)
    arg
               ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
    arg'', FreeVars
    fvs) <- LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
    rnLExpr GenLocated SrcSpanAnnA (HsExpr GhcPs)
    LHsExpr GhcPs
    arg'

               ; let (AmbiguousFieldOcc GhcRn
    lbl', FreeVars
    fvs') = case AmbiguousResult
    mb_sel of
                       UnambiguousGre GreName
    gname -> let sel_name :: Name
    sel_name = GreName -> Name
    greNameMangledName GreName
    gname
                                               in (XUnambiguous GhcRn
    -> GenLocated (SrcAnn NameAnn) RdrName -> AmbiguousFieldOcc GhcRn
    forall pass.
    XUnambiguous pass
    -> GenLocated (SrcAnn NameAnn) RdrName -> AmbiguousFieldOcc pass
    Unambiguous Name
    XUnambiguous GhcRn
    sel_name (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) RdrName
    lbl), FreeVars
    fvs FreeVars -> Name -> FreeVars
    `addOneFV` Name
    sel_name)
                       AmbiguousResult
    AmbiguousFields       -> (XAmbiguous GhcRn
    -> GenLocated (SrcAnn NameAnn) RdrName -> AmbiguousFieldOcc GhcRn
    forall pass.
    XAmbiguous pass
    -> GenLocated (SrcAnn NameAnn) RdrName -> AmbiguousFieldOcc pass
    Ambiguous   NoExtField
    XAmbiguous GhcRn
    noExtField (SrcAnn NameAnn -> RdrName -> GenLocated (SrcAnn NameAnn) RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcAnn NameAnn
    forall ann. SrcSpan -> SrcAnn ann
    noAnnSrcSpan SrcSpan
    loc) RdrName
    lbl), FreeVars
    fvs)

               ; (GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
     FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated
            SrcSpanAnnA
            (HsRecField'
               (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
          FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcSpanAnnA
    -> HsRecField'
         (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn))
    -> GenLocated
         SrcSpanAnnA
         (HsRecField'
            (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    l (HsRecField { hsRecFieldAnn :: XHsRecField (AmbiguousFieldOcc GhcRn)
    hsRecFieldAnn = XHsRecField (AmbiguousFieldOcc GhcRn)
    forall a. EpAnn a
    noAnn
                                         , hsRecFieldLbl :: Located (AmbiguousFieldOcc GhcRn)
    hsRecFieldLbl = SrcSpan
    -> AmbiguousFieldOcc GhcRn -> Located (AmbiguousFieldOcc GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    loc AmbiguousFieldOcc GhcRn
    lbl'
                                         , hsRecFieldArg :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
    hsRecFieldArg = GenLocated SrcSpanAnnA (HsExpr GhcRn)
    arg''
                                         , hsRecPun :: Bool
    hsRecPun      = Bool
    pun }), FreeVars
    fvs') }

        dup_flds :: [NE.NonEmpty RdrName]
            -- Each list represents a RdrName that occurred more than once
            -- (the list contains all occurrences)
            -- Each list in dup_fields is non-empty
        ([RdrName]
    _, [NonEmpty RdrName]
    dup_flds) = (RdrName -> RdrName -> Ordering)
    -> [RdrName] -> ([RdrName], [NonEmpty RdrName])
    forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
    removeDups RdrName -> RdrName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ([LHsRecUpdField GhcPs] -> [RdrName]
    getFieldUpdLbls [LHsRecUpdField GhcPs]
    flds)

    getFieldIds :: [LHsRecField GhcRn arg] -> [Name]
    getFieldIds :: forall arg. [LHsRecField GhcRn arg] -> [Name]
    getFieldIds [LHsRecField GhcRn arg]
    flds = (GenLocated SrcSpanAnnA (HsRecField GhcRn arg) -> Name)
    -> [GenLocated SrcSpanAnnA (HsRecField GhcRn arg)] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (GenLocated SrcSpan Name -> Name
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpan Name -> Name)
    -> (GenLocated SrcSpanAnnA (HsRecField GhcRn arg)
        -> GenLocated SrcSpan Name)
    -> GenLocated SrcSpanAnnA (HsRecField GhcRn arg)
    -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsRecField GhcRn arg -> GenLocated SrcSpan Name
    forall pass arg. HsRecField pass arg -> Located (XCFieldOcc pass)
    hsRecFieldSel (HsRecField GhcRn arg -> GenLocated SrcSpan Name)
    -> (GenLocated SrcSpanAnnA (HsRecField GhcRn arg)
        -> HsRecField GhcRn arg)
    -> GenLocated SrcSpanAnnA (HsRecField GhcRn arg)
    -> GenLocated SrcSpan Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (HsRecField GhcRn arg)
    -> HsRecField GhcRn arg
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated SrcSpanAnnA (HsRecField GhcRn arg)]
    [LHsRecField GhcRn arg]
    flds

    getFieldLbls :: forall p arg . UnXRec p => [LHsRecField p arg] -> [RdrName]
    getFieldLbls :: forall p arg. UnXRec p => [LHsRecField p arg] -> [RdrName]
    getFieldLbls [LHsRecField p arg]
    flds
      = (LHsRecField p arg -> RdrName) -> [LHsRecField p arg] -> [RdrName]
    forall a b. (a -> b) -> [a] -> [b]
    map (GenLocated (SrcAnn NameAnn) RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc (GenLocated (SrcAnn NameAnn) RdrName -> RdrName)
    -> (LHsRecField p arg -> GenLocated (SrcAnn NameAnn) RdrName)
    -> LHsRecField p arg
    -> RdrName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FieldOcc p -> GenLocated (SrcAnn NameAnn) RdrName
    forall pass. FieldOcc pass -> GenLocated (SrcAnn NameAnn) RdrName
    rdrNameFieldOcc (FieldOcc p -> GenLocated (SrcAnn NameAnn) RdrName)
    -> (LHsRecField p arg -> FieldOcc p)
    -> LHsRecField p arg
    -> GenLocated (SrcAnn NameAnn) RdrName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpan (FieldOcc p) -> FieldOcc p
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpan (FieldOcc p) -> FieldOcc p)
    -> (LHsRecField p arg -> GenLocated SrcSpan (FieldOcc p))
    -> LHsRecField p arg
    -> FieldOcc p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsRecField' (FieldOcc p) arg -> GenLocated SrcSpan (FieldOcc p)
    forall id arg. HsRecField' id arg -> Located id
    hsRecFieldLbl (HsRecField' (FieldOcc p) arg -> GenLocated SrcSpan (FieldOcc p))
    -> (LHsRecField p arg -> HsRecField' (FieldOcc p) arg)
    -> LHsRecField p arg
    -> GenLocated SrcSpan (FieldOcc p)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall p a. UnXRec p => XRec p a -> a
    unXRec @p) [LHsRecField p arg]
    flds

    getFieldUpdLbls :: [LHsRecUpdField GhcPs] -> [RdrName]
    getFieldUpdLbls :: [LHsRecUpdField GhcPs] -> [RdrName]
    getFieldUpdLbls [LHsRecUpdField GhcPs]
    flds = (GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
     -> RdrName)
    -> [GenLocated
          SrcSpanAnnA
          (HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    -> [RdrName]
    forall a b. (a -> b) -> [a] -> [b]
    map (AmbiguousFieldOcc GhcPs -> RdrName
    forall (p :: Pass). AmbiguousFieldOcc (GhcPass p) -> RdrName
    rdrNameAmbiguousFieldOcc (AmbiguousFieldOcc GhcPs -> RdrName)
    -> (GenLocated
          SrcSpanAnnA
          (HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
        -> AmbiguousFieldOcc GhcPs)
    -> GenLocated
         SrcSpanAnnA
         (HsRecField'
            (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
    -> RdrName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpan (AmbiguousFieldOcc GhcPs)
    -> AmbiguousFieldOcc GhcPs
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpan (AmbiguousFieldOcc GhcPs)
     -> AmbiguousFieldOcc GhcPs)
    -> (GenLocated
          SrcSpanAnnA
          (HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
        -> GenLocated SrcSpan (AmbiguousFieldOcc GhcPs))
    -> GenLocated
         SrcSpanAnnA
         (HsRecField'
            (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
    -> AmbiguousFieldOcc GhcPs
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsRecField'
      (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
    -> GenLocated SrcSpan (AmbiguousFieldOcc GhcPs)
    forall id arg. HsRecField' id arg -> Located id
    hsRecFieldLbl (HsRecField'
       (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
     -> GenLocated SrcSpan (AmbiguousFieldOcc GhcPs))
    -> (GenLocated
          SrcSpanAnnA
          (HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
        -> HsRecField'
             (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
    -> GenLocated
         SrcSpanAnnA
         (HsRecField'
            (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
    -> GenLocated SrcSpan (AmbiguousFieldOcc GhcPs)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated
      SrcSpanAnnA
      (HsRecField'
         (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
    -> HsRecField'
         (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated
       SrcSpanAnnA
       (HsRecField'
          (AmbiguousFieldOcc GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
    [LHsRecUpdField GhcPs]
    flds

    needFlagDotDot :: HsRecFieldContext -> SDoc
    needFlagDotDot :: HsRecFieldContext -> SDoc
    needFlagDotDot HsRecFieldContext
    ctxt = [SDoc] -> SDoc
    vcat [String -> SDoc
    text String
    "Illegal `..' in record" SDoc -> SDoc -> SDoc
    <+> HsRecFieldContext -> SDoc
    pprRFC HsRecFieldContext
    ctxt,
                                String -> SDoc
    text String
    "Use RecordWildCards to permit this"]

    badDotDotCon :: Name -> SDoc
    badDotDotCon :: Name -> SDoc
    badDotDotCon Name
    con
      = [SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Illegal `..' notation for constructor" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    con)
             , Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "The constructor has no labelled fields") ]

    emptyUpdateErr :: SDoc
    emptyUpdateErr :: SDoc
    emptyUpdateErr = String -> SDoc
    text String
    "Empty record update"

    badPun :: Located RdrName -> SDoc
    badPun :: Located RdrName -> SDoc
    badPun Located RdrName
    fld = [SDoc] -> SDoc
    vcat [String -> SDoc
    text String
    "Illegal use of punning for field" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Located RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Located RdrName
    fld),
                       String -> SDoc
    text String
    "Use NamedFieldPuns to permit this"]

    dupFieldErr :: HsRecFieldContext -> NE.NonEmpty RdrName -> SDoc
    dupFieldErr :: HsRecFieldContext -> NonEmpty RdrName -> SDoc
    dupFieldErr HsRecFieldContext
    ctxt NonEmpty RdrName
    dups
      = [SDoc] -> SDoc
    hsep [String -> SDoc
    text String
    "duplicate field name",
              SDoc -> SDoc
    quotes (RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (NonEmpty RdrName -> RdrName
    forall a. NonEmpty a -> a
    NE.head NonEmpty RdrName
    dups)),
              String -> SDoc
    text String
    "in record", HsRecFieldContext -> SDoc
    pprRFC HsRecFieldContext
    ctxt]

    pprRFC :: HsRecFieldContext -> SDoc
    pprRFC :: HsRecFieldContext -> SDoc
    pprRFC (HsRecFieldCon {}) = String -> SDoc
    text String
    "construction"
    pprRFC (HsRecFieldPat {}) = String -> SDoc
    text String
    "pattern"
    pprRFC (HsRecFieldUpd {}) = String -> SDoc
    text String
    "update"

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection{Literals}
    *                                                                      *
    ************************************************************************

    When literals occur we have to make sure
    that the types and classes they involve
    are made available.
    -}

    rnLit :: HsLit p -> RnM ()
    rnLit :: forall p. HsLit p -> IOEnv (Env TcGblEnv TcLclEnv) ()
    rnLit (HsChar XHsChar p
    _ Char
    c) = Bool -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
    checkErr (Char -> Bool
    inCharRange Char
    c) (Char -> SDoc
    bogusCharError Char
    c)
    rnLit HsLit p
    _ = () -> IOEnv (Env TcGblEnv TcLclEnv) ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    -- | Turn a Fractional-looking literal which happens to be an integer into an
    -- Integer-looking literal.
    -- We only convert numbers where the exponent is between 0 and 100 to avoid
    -- converting huge numbers and incurring long compilation times. See #15646.
    generalizeOverLitVal :: OverLitVal -> OverLitVal
    generalizeOverLitVal :: OverLitVal -> OverLitVal
    generalizeOverLitVal (HsFractional fl :: FractionalLit
    fl@(FL {fl_text :: FractionalLit -> SourceText
    fl_text=SourceText
    src,fl_neg :: FractionalLit -> Bool
    fl_neg=Bool
    neg,fl_exp :: FractionalLit -> Integer
    fl_exp=Integer
    e}))
        | Integer
    e Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    >= -Integer
    100 Bool -> Bool -> Bool
    && Integer
    e Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Integer
    100
        , let val :: Rational
    val = FractionalLit -> Rational
    rationalFromFractionalLit FractionalLit
    fl
        , Rational -> Integer
    forall a. Ratio a -> a
    denominator Rational
    val Integer -> Integer -> Bool
    forall a. Eq a => a -> a -> Bool
    == Integer
    1 = IntegralLit -> OverLitVal
    HsIntegral (IL {il_text :: SourceText
    il_text=SourceText
    src,il_neg :: Bool
    il_neg=Bool
    neg,il_value :: Integer
    il_value=Rational -> Integer
    forall a. Ratio a -> a
    numerator Rational
    val})
    generalizeOverLitVal OverLitVal
    lit = OverLitVal
    lit

    isNegativeZeroOverLit :: HsOverLit t -> Bool
    isNegativeZeroOverLit :: forall t. HsOverLit t -> Bool
    isNegativeZeroOverLit HsOverLit t
    lit
     = case HsOverLit t -> OverLitVal
    forall p. HsOverLit p -> OverLitVal
    ol_val HsOverLit t
    lit of
            HsIntegral IntegralLit
    i    -> Integer
    0 Integer -> Integer -> Bool
    forall a. Eq a => a -> a -> Bool
    == IntegralLit -> Integer
    il_value IntegralLit
    i Bool -> Bool -> Bool
    && IntegralLit -> Bool
    il_neg IntegralLit
    i
            -- For HsFractional, the value of fl is n * (b ^^ e) so it is sufficient
            -- to check if n = 0. b is equal to either 2 or 10. We don't call
            -- rationalFromFractionalLit here as it is expensive when e is big.
            HsFractional FractionalLit
    fl -> Rational
    0 Rational -> Rational -> Bool
    forall a. Eq a => a -> a -> Bool
    == FractionalLit -> Rational
    fl_signi FractionalLit
    fl Bool -> Bool -> Bool
    && FractionalLit -> Bool
    fl_neg FractionalLit
    fl
            OverLitVal
    _               -> Bool
    False

    {-
    Note [Negative zero]
    ~~~~~~~~~~~~~~~~~~~~~~~~~
    There were problems with negative zero in conjunction with Negative Literals
    extension. Numeric literal value is contained in Integer and Rational types
    inside IntegralLit and FractionalLit. These types cannot represent negative
    zero value. So we had to add explicit field 'neg' which would hold information
    about literal sign. Here in rnOverLit we use it to detect negative zeroes and
    in this case return not only literal itself but also negateName so that users
    can apply it explicitly. In this case it stays negative zero.  #13211
    -}

    rnOverLit :: HsOverLit t ->
                 RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    rnOverLit :: forall t.
    HsOverLit t
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    rnOverLit HsOverLit t
    origLit
      = do  { Bool
    opt_NumDecimals <- Extension -> RnM Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.NumDecimals
            ; let { lit :: HsOverLit t
    lit@(OverLit {ol_val :: forall p. HsOverLit p -> OverLitVal
    ol_val=OverLitVal
    val})
                | Bool
    opt_NumDecimals = HsOverLit t
    origLit {ol_val :: OverLitVal
    ol_val = OverLitVal -> OverLitVal
    generalizeOverLitVal (HsOverLit t -> OverLitVal
    forall p. HsOverLit p -> OverLitVal
    ol_val HsOverLit t
    origLit)}
                | Bool
    otherwise       = HsOverLit t
    origLit
              }
            ; let std_name :: Name
    std_name = OverLitVal -> Name
    hsOverLitName OverLitVal
    val
            ; (Name
    from_thing_name, FreeVars
    fvs1) <- Name -> RnM (Name, FreeVars)
    lookupSyntaxName Name
    std_name
            ; let rebindable :: Bool
    rebindable = Name
    from_thing_name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Name
    std_name
                  lit' :: HsOverLit GhcRn
    lit' = HsOverLit t
    lit { ol_witness :: HsExpr GhcRn
    ol_witness = IdP GhcRn -> HsExpr GhcRn
    forall (p :: Pass) a.
    IsSrcSpanAnn p a =>
    IdP (GhcPass p) -> HsExpr (GhcPass p)
    nl_HsVar Name
    IdP GhcRn
    from_thing_name
                             , ol_ext :: XOverLit GhcRn
    ol_ext = Bool
    XOverLit GhcRn
    rebindable }
            ; if HsOverLit GhcRn -> Bool
    forall t. HsOverLit t -> Bool
    isNegativeZeroOverLit HsOverLit GhcRn
    lit'
              then do { (HsExpr GhcRn
    negate_name, FreeVars
    fvs2) <- Name -> RnM (HsExpr GhcRn, FreeVars)
    lookupSyntaxExpr Name
    negateName
                      ; ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((HsOverLit GhcRn
    lit' { ol_val :: OverLitVal
    ol_val = OverLitVal -> OverLitVal
    negateOverLitVal OverLitVal
    val }, HsExpr GhcRn -> Maybe (HsExpr GhcRn)
    forall a. a -> Maybe a
    Just HsExpr GhcRn
    negate_name)
                                      , FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs2) }
              else ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((HsOverLit GhcRn
    lit', Maybe (HsExpr GhcRn)
    forall a. Maybe a
    Nothing), FreeVars
    fvs1) }

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection{Errors}
    *                                                                      *
    ************************************************************************
    -}

    patSigErr :: Outputable a => a -> SDoc
    patSigErr :: forall a. Outputable a => a -> SDoc
    patSigErr a
    ty
      =  (String -> SDoc
    text String
    "Illegal signature in pattern:" SDoc -> SDoc -> SDoc
    <+> a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    ty)
            SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    4 (String -> SDoc
    text String
    "Use ScopedTypeVariables to permit it")

    bogusCharError :: Char -> SDoc
    bogusCharError :: Char -> SDoc
    bogusCharError Char
    c
      = String -> SDoc
    text String
    "character literal out of range: '\\" SDoc -> SDoc -> SDoc
    <> Char -> SDoc
    char Char
    c  SDoc -> SDoc -> SDoc
    <> Char -> SDoc
    char Char
    '\''

    badViewPat :: Pat GhcPs -> SDoc
    badViewPat :: Pat GhcPs -> SDoc
    badViewPat Pat GhcPs
    pat = [SDoc] -> SDoc
    vcat [String -> SDoc
    text String
    "Illegal view pattern: " SDoc -> SDoc -> SDoc
    <+> Pat GhcPs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Pat GhcPs
    pat,
                           String -> SDoc
    text String
    "Use ViewPatterns to enable view patterns"]