    {-# LANGUAGE FlexibleContexts    #-}
    {-# LANGUAGE NamedFieldPuns      #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies        #-}

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

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

    Main pass of renamer
    -}

    module GHC.Rename.Module (
            rnSrcDecls, addTcgDUs, findSplice, rnWarningTxt, rnLWarningTxt
        ) where

    import GHC.Prelude hiding ( head )

    import {-# SOURCE #-} GHC.Rename.Expr( rnLExpr )
    import {-# SOURCE #-} GHC.Rename.Splice ( rnSpliceDecl, rnTopSpliceDecls )

    import GHC.Hs
    import GHC.Types.FieldLabel
    import GHC.Types.Name.Reader
    import GHC.Rename.HsType
    import GHC.Rename.Bind
    import GHC.Rename.Doc
    import GHC.Rename.Env
    import GHC.Rename.Utils ( mapFvRn, bindLocalNames
                            , checkDupRdrNames, bindLocalNamesFV
                            , checkShadowedRdrNames, warnUnusedTypePatterns
                            , newLocalBndrsRn
                            , noNestedForallsContextsErr
                            , addNoNestedForallsContextsErr, checkInferredVars )
    import GHC.Rename.Unbound ( mkUnboundName, notInScopeErr, WhereLooking(WL_Global) )
    import GHC.Rename.Names
    import GHC.Tc.Errors.Types
    import GHC.Tc.Gen.Annotation ( annCtxt )
    import GHC.Tc.Utils.Monad
    import GHC.Tc.Types.Origin ( TypedThing(..) )

    import GHC.Types.ForeignCall ( CCallTarget(..) )
    import GHC.Unit
    import GHC.Unit.Module.Warnings
    import GHC.Builtin.Names( applicativeClassName, pureAName, thenAName
                            , monadClassName, returnMName, thenMName
                            , semigroupClassName, sappendName
                            , monoidClassName, mappendName
                            )
    import GHC.Types.Name
    import GHC.Types.Name.Set
    import GHC.Types.Name.Env
    import GHC.Utils.Outputable
    import GHC.Data.Bag
    import GHC.Types.Basic  ( TypeOrKind(..) )
    import GHC.Data.FastString
    import GHC.Types.SrcLoc as SrcLoc
    import GHC.Driver.DynFlags
    import GHC.Utils.Misc   ( lengthExceeds, partitionWith )
    import GHC.Utils.Panic
    import GHC.Driver.Env ( HscEnv(..), hsc_home_unit)
    import GHC.Data.List.SetOps ( findDupsEq, removeDupsOn, equivClasses )
    import GHC.Data.Graph.Directed ( SCC, flattenSCC, flattenSCCs, Node(..)
                                   , stronglyConnCompFromEdgedVerticesUniq )
    import GHC.Types.Unique.Set
    import GHC.Data.OrdList
    import qualified GHC.LanguageExtensions as LangExt
    import GHC.Core.DataCon ( isSrcStrict )

    import Control.Monad
    import Control.Arrow ( first )
    import Data.Foldable ( toList, for_ )
    import Data.List ( mapAccumL )
    import Data.List.NonEmpty ( NonEmpty(..), head, nonEmpty )
    import Data.Maybe ( isNothing, fromMaybe, mapMaybe )
    import qualified Data.Set as Set ( difference, fromList, toList, null )
    import GHC.Types.GREInfo (ConInfo, mkConInfo, conInfoFields)

    {- | @rnSourceDecl@ "renames" declarations.
    It simultaneously performs dependency analysis and precedence parsing.
    It also does the following error checks:

    * Checks that tyvars are used properly. This includes checking
      for undefined tyvars, and tyvars in contexts that are ambiguous.
      (Some of this checking has now been moved to module @TcMonoType@,
      since we don't have functional dependency information at this point.)

    * Checks that all variable occurrences are defined.

    * Checks the @(..)@ etc constraints in the export list.

    Brings the binders of the group into scope in the appropriate places;
    does NOT assume that anything is in scope already
    -}
    rnSrcDecls :: HsGroup GhcPs -> RnM (TcGblEnv, HsGroup GhcRn)
    -- Rename a top-level HsGroup; used for normal source files *and* hs-boot files
    rnSrcDecls :: HsGroup GhcPs -> RnM (TcGblEnv, HsGroup GhcRn)
    rnSrcDecls group :: HsGroup GhcPs
    group@(HsGroup { hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds   = HsValBinds GhcPs
    val_decls,
                                hs_splcds :: forall p. HsGroup p -> [LSpliceDecl p]
    hs_splcds  = [LSpliceDecl GhcPs]
    splice_decls,
                                hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds  = [TyClGroup GhcPs]
    tycl_decls,
                                hs_derivds :: forall p. HsGroup p -> [LDerivDecl p]
    hs_derivds = [LDerivDecl GhcPs]
    deriv_decls,
                                hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds   = [LFixitySig GhcPs]
    fix_decls,
                                hs_warnds :: forall p. HsGroup p -> [LWarnDecls p]
    hs_warnds  = [LWarnDecls GhcPs]
    warn_decls,
                                hs_annds :: forall p. HsGroup p -> [LAnnDecl p]
    hs_annds   = [LAnnDecl GhcPs]
    ann_decls,
                                hs_fords :: forall p. HsGroup p -> [LForeignDecl p]
    hs_fords   = [LForeignDecl GhcPs]
    foreign_decls,
                                hs_defds :: forall p. HsGroup p -> [LDefaultDecl p]
    hs_defds   = [LDefaultDecl GhcPs]
    default_decls,
                                hs_ruleds :: forall p. HsGroup p -> [LRuleDecls p]
    hs_ruleds  = [LRuleDecls GhcPs]
    rule_decls,
                                hs_docs :: forall p. HsGroup p -> [LDocDecl p]
    hs_docs    = [LDocDecl GhcPs]
    docs })
     = do {
       -- (A) Process the top-level fixity declarations, creating a mapping from
       --     FastStrings to FixItems. Also checks for duplicates.
       --     See Note [Top-level fixity signatures in an HsGroup] in GHC.Hs.Decls
       local_fix_env <- [LFixitySig GhcPs] -> RnM MiniFixityEnv
    makeMiniFixityEnv ([LFixitySig GhcPs] -> RnM MiniFixityEnv)
    -> [LFixitySig GhcPs] -> RnM MiniFixityEnv
    forall a b. (a -> b) -> a -> b
    $ HsGroup GhcPs -> [LFixitySig GhcPs]
    forall (p :: Pass). HsGroup (GhcPass p) -> [LFixitySig (GhcPass p)]
    hsGroupTopLevelFixitySigs HsGroup GhcPs
    group ;

       -- (B) Bring top level binders (and their fixities) into scope,
       --     *except* for the value bindings, which get done in step (D)
       --     with collectHsIdBinders. However *do* include
       --
       --        * Class ops, data constructors, and record fields,
       --          because they do not have value declarations.
       --
       --        * For hs-boot files, include the value signatures
       --          Again, they have no value declarations
       --
       (tc_envs, tc_bndrs) <- getLocalNonValBinders local_fix_env group ;

       restoreEnvs tc_envs $ do {

       failIfErrsM ; -- No point in continuing if (say) we have duplicate declarations

       -- (D1) Bring pattern synonyms into scope.
       --      Need to do this before (D2) because rnTopBindsLHS
       --      looks up those pattern synonyms (#9889)

       dup_fields_ok <- xopt_DuplicateRecordFields <$> getDynFlags ;
       has_sel <- xopt_FieldSelectors <$> getDynFlags ;
       extendPatSynEnv dup_fields_ok has_sel val_decls local_fix_env $ \[Name]
    pat_syn_bndrs -> do {

       -- (D2) Rename the left-hand sides of the value bindings.
       --     This depends on everything from (B) being in scope.
       --     It uses the fixity env from (A) to bind fixities for view patterns.

       -- We need to throw an error on such value bindings when in a boot file.
       is_boot <- TcRn Bool
    tcIsHsBootOrSig ;
       new_lhs <- if is_boot
        then rnTopBindsLHSBoot local_fix_env val_decls
        else rnTopBindsLHS     local_fix_env val_decls ;

       -- Bind the LHSes (and their fixities) in the global rdr environment
       let { id_bndrs = CollectFlag GhcRn -> HsValBindsLR GhcRn GhcPs -> [IdP GhcRn]
    forall (idL :: Pass) (idR :: Pass).
    CollectPass (GhcPass idL) =>
    CollectFlag (GhcPass idL)
    -> HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
    collectHsIdBinders CollectFlag GhcRn
    forall p. CollectFlag p
    CollNoDictBinders HsValBindsLR GhcRn GhcPs
    new_lhs } ;
                        -- Excludes pattern-synonym binders
                        -- They are already in scope
       traceRn "rnSrcDecls" (ppr id_bndrs) ;
       tc_envs <- extendGlobalRdrEnvRn (map (mkLocalVanillaGRE NoParent) id_bndrs) local_fix_env ;
       restoreEnvs tc_envs $ do {

       --  Now everything is in scope, as the remaining renaming assumes.

       -- (E) Rename type and class decls
       --     (note that value LHSes need to be in scope for default methods)
       --
       -- You might think that we could build proper def/use information
       -- for type and class declarations, but they can be involved
       -- in mutual recursion across modules, and we only do the SCC
       -- analysis for them in the type checker.
       -- So we content ourselves with gathering uses only; that
       -- means we'll only report a declaration as unused if it isn't
       -- mentioned at all.  Ah well.
       traceRn "Start rnTyClDecls" (ppr tycl_decls) ;
       (rn_tycl_decls, src_fvs1) <- rnTyClDecls tycl_decls ;

       -- (F) Rename Value declarations right-hand sides
       traceRn "Start rnmono" empty ;
       let { val_bndr_set = [Name] -> FreeVars
    mkNameSet [IdP GhcRn]
    [Name]
    id_bndrs FreeVars -> FreeVars -> FreeVars
    `unionNameSet` [Name] -> FreeVars
    mkNameSet [Name]
    pat_syn_bndrs } ;
       (rn_val_decls, bind_dus) <- if is_boot
        -- For an hs-boot, use tc_bndrs (which collects how we're renamed
        -- signatures), since val_bndr_set is empty (there are no x = ...
        -- bindings in an hs-boot.)
        then rnTopBindsBoot tc_bndrs new_lhs
        else rnValBindsRHS (TopSigCtxt val_bndr_set) new_lhs ;
       traceRn "finish rnmono" (ppr rn_val_decls) ;

       -- (G) Rename Fixity and deprecations

       -- Rename fixity declarations and error if we try to
       -- fix something from another module (duplicates were checked in (A))
       let { all_bndrs = FreeVars
    tc_bndrs FreeVars -> FreeVars -> FreeVars
    `unionNameSet` FreeVars
    val_bndr_set } ;
       traceRn "rnSrcDecls fixity" $
         vcat [ text "all_bndrs:" <+> ppr all_bndrs ] ;
       rn_fix_decls <- mapM (mapM (rnSrcFixityDecl (TopSigCtxt all_bndrs)))
                            fix_decls ;

       -- Rename deprec decls;
       -- check for duplicates and ensure that deprecated things are defined locally
       -- at the moment, we don't keep these around past renaming
       rn_decl_warns <- rnSrcWarnDecls all_bndrs warn_decls ;

       -- (H) Rename Everything else

       (rn_rule_decls,    src_fvs2) <- setXOptM LangExt.ScopedTypeVariables $
                                       rnList rnHsRuleDecls rule_decls ;
                               -- Inside RULES, scoped type variables are on
       (rn_foreign_decls, src_fvs3) <- rnList rnHsForeignDecl foreign_decls ;
       (rn_ann_decls,     src_fvs4) <- rnList rnAnnDecl       ann_decls ;
       (rn_default_decls, src_fvs5) <- rnList rnDefaultDecl   default_decls ;
       (rn_deriv_decls,   src_fvs6) <- rnList rnSrcDerivDecl  deriv_decls ;
       (rn_splice_decls,  src_fvs7) <- rnList rnSpliceDecl    splice_decls ;
       rn_docs <- traverse rnLDocDecl docs ;

       last_tcg_env <- getGblEnv ;
       -- (I) Compute the results and return
       let {rn_group = HsGroup { hs_ext :: XCHsGroup GhcRn
    hs_ext     = XCHsGroup GhcRn
    NoExtField
    noExtField,
                                 hs_valds :: HsValBinds GhcRn
    hs_valds   = HsValBinds GhcRn
    rn_val_decls,
                                 hs_splcds :: [LSpliceDecl GhcRn]
    hs_splcds  = [LSpliceDecl GhcRn]
    [LocatedA (SpliceDecl GhcRn)]
    rn_splice_decls,
                                 hs_tyclds :: [TyClGroup GhcRn]
    hs_tyclds  = [TyClGroup GhcRn]
    rn_tycl_decls,
                                 hs_derivds :: [LDerivDecl GhcRn]
    hs_derivds = [LDerivDecl GhcRn]
    [LocatedA (DerivDecl GhcRn)]
    rn_deriv_decls,
                                 hs_fixds :: [LFixitySig GhcRn]
    hs_fixds   = [LFixitySig GhcRn]
    [GenLocated SrcSpanAnnA (FixitySig GhcRn)]
    rn_fix_decls,
                                 hs_warnds :: [LWarnDecls GhcRn]
    hs_warnds  = [], -- warns are returned in the tcg_env
                                                 -- (see below) not in the HsGroup
                                 hs_fords :: [LForeignDecl GhcRn]
    hs_fords  = [LForeignDecl GhcRn]
    [LocatedA (ForeignDecl GhcRn)]
    rn_foreign_decls,
                                 hs_annds :: [LAnnDecl GhcRn]
    hs_annds  = [LAnnDecl GhcRn]
    [LocatedA (AnnDecl GhcRn)]
    rn_ann_decls,
                                 hs_defds :: [LDefaultDecl GhcRn]
    hs_defds  = [LDefaultDecl GhcRn]
    [LocatedA (DefaultDecl GhcRn)]
    rn_default_decls,
                                 hs_ruleds :: [LRuleDecls GhcRn]
    hs_ruleds = [LRuleDecls GhcRn]
    [LocatedA (RuleDecls GhcRn)]
    rn_rule_decls,
                                 hs_docs :: [LDocDecl GhcRn]
    hs_docs   = [LDocDecl GhcRn]
    [GenLocated SrcSpanAnnA (DocDecl GhcRn)]
    rn_docs } ;

            tcf_bndrs = [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name]
    hsTyClForeignBinders [TyClGroup GhcRn]
    rn_tycl_decls [LForeignDecl GhcRn]
    [LocatedA (ForeignDecl GhcRn)]
    rn_foreign_decls ;
            other_def  = (FreeVars -> Maybe FreeVars
    forall a. a -> Maybe a
    Just ([Name] -> FreeVars
    mkNameSet [Name]
    tcf_bndrs), FreeVars
    emptyNameSet) ;
            other_fvs  = [FreeVars] -> FreeVars
    plusFVs [FreeVars
    src_fvs1, FreeVars
    src_fvs2, FreeVars
    src_fvs3, FreeVars
    src_fvs4,
                                  FreeVars
    src_fvs5, FreeVars
    src_fvs6, FreeVars
    src_fvs7] ;
                    -- It is tiresome to gather the binders from type and class decls

            src_dus = (Maybe FreeVars, FreeVars) -> DefUses
    forall a. a -> OrdList a
    unitOL (Maybe FreeVars, FreeVars)
    other_def DefUses -> DefUses -> DefUses
    `plusDU` DefUses
    bind_dus DefUses -> DefUses -> DefUses
    `plusDU` FreeVars -> DefUses
    usesOnly FreeVars
    other_fvs ;
                    -- Instance decls may have occurrences of things bound in bind_dus
                    -- so we must put other_fvs last

            final_tcg_env = let tcg_env' :: TcGblEnv
    tcg_env' = (TcGblEnv
    last_tcg_env TcGblEnv -> DefUses -> TcGblEnv
    `addTcgDUs` DefUses
    src_dus)
                            in -- we return the deprecs in the env, not in the HsGroup above
                            TcGblEnv
    tcg_env' { tcg_warns = insertWarnDecls (tcg_warns tcg_env') rn_decl_warns };
           } ;
       traceRn "finish rnSrc" (ppr rn_group) ;
       traceRn "finish Dus" (ppr src_dus ) ;
       return (final_tcg_env, rn_group)
                        }}}}

    addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv
    -- This function could be defined lower down in the module hierarchy,
    -- but there doesn't seem anywhere very logical to put it.
    addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv
    addTcgDUs TcGblEnv
    tcg_env DefUses
    dus = TcGblEnv
    tcg_env { tcg_dus = tcg_dus tcg_env `plusDU` dus }

    rnList :: (a -> RnM (b, FreeVars)) -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList :: forall a b.
    (a -> RnM (b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList a -> RnM (b, FreeVars)
    f [LocatedA a]
    xs = (LocatedA a -> RnM (LocatedA b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    forall (f :: * -> *) a b.
    Traversable f =>
    (a -> RnM (b, FreeVars)) -> f a -> RnM (f b, FreeVars)
    mapFvRn ((a -> RnM (b, FreeVars))
    -> LocatedA a -> RnM (LocatedA b, FreeVars)
    forall a b c ann.
    (a -> TcM (b, c))
    -> GenLocated (EpAnn ann) a -> TcM (GenLocated (EpAnn ann) b, c)
    wrapLocFstMA a -> RnM (b, FreeVars)
    f) [LocatedA a]
    xs

    {-
    *********************************************************
    *                                                       *
            Source-code deprecations declarations
    *                                                       *
    *********************************************************

    Check that the deprecated names are defined, are defined locally, and
    that there are no duplicate deprecations.

    It's only imported deprecations, dealt with in RnIfaces, that we
    gather them together.
    -}

    -- checks that the deprecations are defined locally, and that there are no duplicates
    rnSrcWarnDecls :: NameSet -> [LWarnDecls GhcPs] -> RnM (DeclWarnOccNames GhcRn)
    rnSrcWarnDecls :: FreeVars -> [LWarnDecls GhcPs] -> RnM (DeclWarnOccNames GhcRn)
    rnSrcWarnDecls FreeVars
    _ []
      = DeclWarnOccNames GhcRn -> RnM (DeclWarnOccNames GhcRn)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []

    rnSrcWarnDecls FreeVars
    bndr_set [LWarnDecls GhcPs]
    decls'
      = do { -- check for duplicates
           ; (NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
     -> TcRn ())
    -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (\ NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
    dups -> let ((L SrcSpanAnnN
    loc RdrName
    rdr) :| (GenLocated SrcSpanAnnN RdrName
    lrdr':FreeKiTyVars
    _)) = ((NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
     -> GenLocated SrcSpanAnnN RdrName)
    -> NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
    -> NonEmpty (GenLocated SrcSpanAnnN RdrName)
    forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
    -> GenLocated SrcSpanAnnN RdrName
    forall a b. (a, b) -> b
    snd NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
    dups
                              in SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt (SrcSpanAnnN -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnN
    loc) (GenLocated SrcSpanAnnN RdrName -> RdrName -> TcRnMessage
    TcRnDuplicateWarningDecls GenLocated SrcSpanAnnN RdrName
    lrdr' RdrName
    rdr))
                   [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    warn_rdr_dups
           ; pairs_s <- (GenLocated SrcSpanAnnA (WarnDecl GhcPs)
     -> RnM (DeclWarnOccNames GhcRn))
    -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [DeclWarnOccNames GhcRn]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((WarnDecl GhcPs -> RnM (DeclWarnOccNames GhcRn))
    -> GenLocated SrcSpanAnnA (WarnDecl GhcPs)
    -> RnM (DeclWarnOccNames GhcRn)
    forall t a b. HasLoc t => (a -> TcM b) -> GenLocated t a -> TcM b
    addLocM WarnDecl GhcPs -> RnM (DeclWarnOccNames GhcRn)
    rn_deprec) [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    decls
           ; return $ concat pairs_s }
     where
       decls :: [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    decls = (GenLocated SrcSpanAnnA (WarnDecls GhcPs)
     -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)])
    -> [GenLocated SrcSpanAnnA (WarnDecls GhcPs)]
    -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (WarnDecls GhcPs -> [LWarnDecl GhcPs]
    WarnDecls GhcPs -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    forall pass. WarnDecls pass -> [LWarnDecl pass]
    wd_warnings (WarnDecls GhcPs -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)])
    -> (GenLocated SrcSpanAnnA (WarnDecls GhcPs) -> WarnDecls GhcPs)
    -> GenLocated SrcSpanAnnA (WarnDecls GhcPs)
    -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (WarnDecls GhcPs) -> WarnDecls GhcPs
    forall l e. GenLocated l e -> e
    unLoc) [LWarnDecls GhcPs]
    [GenLocated SrcSpanAnnA (WarnDecls GhcPs)]
    decls'

       sig_ctxt :: HsSigCtxt
    sig_ctxt = FreeVars -> HsSigCtxt
    TopSigCtxt FreeVars
    bndr_set

       rn_deprec :: WarnDecl GhcPs -> RnM (DeclWarnOccNames GhcRn)
    rn_deprec w :: WarnDecl GhcPs
    w@(Warning (NamespaceSpecifier
    ns_spec, [AddEpAnn]
    _) [LIdP GhcPs]
    rdr_names WarningTxt GhcPs
    txt)
           -- ensures that the names are defined locally
         = do { names <- (GenLocated SrcSpanAnnN RdrName
     -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)])
    -> FreeKiTyVars -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
    forall (m :: * -> *) (f :: * -> *) a b.
    (Monad m, Traversable f) =>
    (a -> m [b]) -> f a -> m [b]
    concatMapM (HsSigCtxt
    -> SDoc
    -> NamespaceSpecifier
    -> RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
    lookupLocalTcNames HsSigCtxt
    sig_ctxt SDoc
    what NamespaceSpecifier
    ns_spec (RdrName -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)])
    -> (GenLocated SrcSpanAnnN RdrName -> RdrName)
    -> GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnN RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc)
                                    [LIdP GhcPs]
    FreeKiTyVars
    rdr_names
              ; unlessXOptM LangExt.ExplicitNamespaces $
                when (ns_spec /= NoNamespaceSpecifier) $
                addErr (TcRnNamespacedWarningPragmaWithoutFlag w)
              ; txt' <- rnWarningTxt txt
              ; return [(nameOccName nm, txt') | (_, nm) <- names] }
      -- Use the OccName from the Name we looked up, rather than from the RdrName,
      -- as we might hit multiple different NameSpaces when looking up
      -- (e.g. deprecating both a variable and a record field).

       what :: SDoc
    what = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "deprecation"

       warn_rdr_dups :: [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    warn_rdr_dups = [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    find_dup_warning_names
                       ([(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
     -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)])
    -> [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    forall a b. (a -> b) -> a -> b
    $ (GenLocated SrcSpanAnnA (WarnDecl GhcPs)
     -> [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)])
    -> [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    -> [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (\(L SrcSpanAnnA
    _ (Warning (NamespaceSpecifier
    ns_spec, [AddEpAnn]
    _) [LIdP GhcPs]
    ns WarningTxt GhcPs
    _)) -> (NamespaceSpecifier
    ns_spec,) (GenLocated SrcSpanAnnN RdrName
     -> (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName))
    -> FreeKiTyVars
    -> [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [LIdP GhcPs]
    FreeKiTyVars
    ns) [GenLocated SrcSpanAnnA (WarnDecl GhcPs)]
    decls

       find_dup_warning_names :: [(NamespaceSpecifier, LocatedN RdrName)] -> [NonEmpty (NamespaceSpecifier, LocatedN RdrName)]
       find_dup_warning_names :: [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    find_dup_warning_names = ((NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)
     -> (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName) -> Bool)
    -> [(NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    -> [NonEmpty (NamespaceSpecifier, GenLocated SrcSpanAnnN RdrName)]
    forall a. (a -> a -> Bool) -> [a] -> [NonEmpty a]
    findDupsEq (\ (NamespaceSpecifier
    spec1, GenLocated SrcSpanAnnN RdrName
    x) -> \ (NamespaceSpecifier
    spec2, GenLocated SrcSpanAnnN RdrName
    y) ->
                                  NamespaceSpecifier -> NamespaceSpecifier -> Bool
    overlappingNamespaceSpecifiers NamespaceSpecifier
    spec1 NamespaceSpecifier
    spec2 Bool -> Bool -> Bool
    &&
                                  RdrName -> OccName
    rdrNameOcc (GenLocated SrcSpanAnnN RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnN RdrName
    x) OccName -> OccName -> Bool
    forall a. Eq a => a -> a -> Bool
    == RdrName -> OccName
    rdrNameOcc (GenLocated SrcSpanAnnN RdrName -> RdrName
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnN RdrName
    y))

    rnWarningTxt :: WarningTxt GhcPs -> RnM (WarningTxt GhcRn)
    rnWarningTxt :: WarningTxt GhcPs -> RnM (WarningTxt GhcRn)
    rnWarningTxt (WarningTxt Maybe (LocatedE InWarningCategory)
    mb_cat SourceText
    st [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    wst) = do
      Maybe (LocatedE InWarningCategory)
    -> (LocatedE InWarningCategory -> TcRn ()) -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ Maybe (LocatedE InWarningCategory)
    mb_cat ((LocatedE InWarningCategory -> TcRn ()) -> TcRn ())
    -> (LocatedE InWarningCategory -> TcRn ()) -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ \(L EpaLocation
    _ (InWarningCategory EpToken "in"
    _ SourceText
    _ (L EpaLocation
    loc WarningCategory
    cat))) ->
        Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (WarningCategory -> Bool
    validWarningCategory WarningCategory
    cat) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
          SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt (EpaLocation -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA EpaLocation
    loc) (WarningCategory -> TcRnMessage
    TcRnInvalidWarningCategory WarningCategory
    cat)
      wst' <- (LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated
             EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn)))
    -> [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ((WithHsDocIdentifiers StringLiteral GhcPs
     -> IOEnv
          (Env TcGblEnv TcLclEnv) (WithHsDocIdentifiers StringLiteral GhcRn))
    -> LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b)
    -> GenLocated EpaLocation a -> f (GenLocated EpaLocation b)
    traverse WithHsDocIdentifiers StringLiteral GhcPs
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (WithHsDocIdentifiers StringLiteral GhcRn)
    forall a.
    WithHsDocIdentifiers a GhcPs -> RnM (WithHsDocIdentifiers a GhcRn)
    rnHsDoc) [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    wst
      pure (WarningTxt mb_cat st wst')
    rnWarningTxt (DeprecatedTxt SourceText
    st [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    wst) = do
      wst' <- (LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated
             EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn)))
    -> [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ((WithHsDocIdentifiers StringLiteral GhcPs
     -> IOEnv
          (Env TcGblEnv TcLclEnv) (WithHsDocIdentifiers StringLiteral GhcRn))
    -> LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated EpaLocation (WithHsDocIdentifiers StringLiteral GhcRn))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b)
    -> GenLocated EpaLocation a -> f (GenLocated EpaLocation b)
    traverse WithHsDocIdentifiers StringLiteral GhcPs
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (WithHsDocIdentifiers StringLiteral GhcRn)
    forall a.
    WithHsDocIdentifiers a GhcPs -> RnM (WithHsDocIdentifiers a GhcRn)
    rnHsDoc) [LocatedE (WithHsDocIdentifiers StringLiteral GhcPs)]
    wst
      pure (DeprecatedTxt st wst')

    rnLWarningTxt :: LWarningTxt GhcPs -> RnM (LWarningTxt GhcRn)
    rnLWarningTxt :: LWarningTxt GhcPs -> RnM (LWarningTxt GhcRn)
    rnLWarningTxt (L SrcSpanAnnP
    loc WarningTxt GhcPs
    warn) = SrcSpanAnnP
    -> WarningTxt GhcRn -> GenLocated SrcSpanAnnP (WarningTxt GhcRn)
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnP
    loc (WarningTxt GhcRn -> GenLocated SrcSpanAnnP (WarningTxt GhcRn))
    -> RnM (WarningTxt GhcRn)
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnP (WarningTxt GhcRn))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> WarningTxt GhcPs -> RnM (WarningTxt GhcRn)
    rnWarningTxt WarningTxt GhcPs
    warn

    -- look for duplicates among the OccNames;
    -- we check that the names are defined above
    -- invt: the lists returned by findDupsEq always have at least two elements

    {-
    *********************************************************
    *                                                      *
    \subsection{Annotation declarations}
    *                                                      *
    *********************************************************
    -}

    rnAnnDecl :: AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars)
    rnAnnDecl :: AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars)
    rnAnnDecl ann :: AnnDecl GhcPs
    ann@(HsAnnotation (AnnPragma
    _, SourceText
    s) AnnProvenance GhcPs
    provenance XRec GhcPs (HsExpr GhcPs)
    expr)
      = SDoc
    -> RnM (AnnDecl GhcRn, FreeVars) -> RnM (AnnDecl GhcRn, FreeVars)
    forall a. SDoc -> TcM a -> TcM a
    addErrCtxt (AnnDecl GhcPs -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    AnnDecl (GhcPass p) -> SDoc
    annCtxt AnnDecl GhcPs
    ann) (RnM (AnnDecl GhcRn, FreeVars) -> RnM (AnnDecl GhcRn, FreeVars))
    -> RnM (AnnDecl GhcRn, FreeVars) -> RnM (AnnDecl GhcRn, FreeVars)
    forall a b. (a -> b) -> a -> b
    $
        do { (provenance', provenance_fvs) <- AnnProvenance GhcPs -> RnM (AnnProvenance GhcRn, FreeVars)
    rnAnnProvenance AnnProvenance GhcPs
    provenance
           ; (expr', expr_fvs) <- setStage (Splice Untyped) $
                                  rnLExpr expr
           ; return (HsAnnotation (noAnn, s) provenance' expr',
                     provenance_fvs `plusFV` expr_fvs) }

    rnAnnProvenance :: AnnProvenance GhcPs
                    -> RnM (AnnProvenance GhcRn, FreeVars)
    rnAnnProvenance :: AnnProvenance GhcPs -> RnM (AnnProvenance GhcRn, FreeVars)
    rnAnnProvenance AnnProvenance GhcPs
    provenance = do
        provenance' <- case AnnProvenance GhcPs
    provenance of
          ValueAnnProvenance LIdP GhcPs
    n -> LIdP GhcRn -> AnnProvenance GhcRn
    GenLocated SrcSpanAnnN Name -> AnnProvenance GhcRn
    forall pass. LIdP pass -> AnnProvenance pass
    ValueAnnProvenance
                              (GenLocated SrcSpanAnnN Name -> AnnProvenance GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    -> IOEnv (Env TcGblEnv TcLclEnv) (AnnProvenance GhcRn)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopBndrRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    n
          TypeAnnProvenance LIdP GhcPs
    n  -> LIdP GhcRn -> AnnProvenance GhcRn
    GenLocated SrcSpanAnnN Name -> AnnProvenance GhcRn
    forall pass. LIdP pass -> AnnProvenance pass
    TypeAnnProvenance
                              (GenLocated SrcSpanAnnN Name -> AnnProvenance GhcRn)
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    -> IOEnv (Env TcGblEnv TcLclEnv) (AnnProvenance GhcRn)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    n
          AnnProvenance GhcPs
    ModuleAnnProvenance  -> AnnProvenance GhcRn
    -> IOEnv (Env TcGblEnv TcLclEnv) (AnnProvenance GhcRn)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AnnProvenance GhcRn
    forall pass. AnnProvenance pass
    ModuleAnnProvenance
        return (provenance', maybe emptyFVs unitFV (annProvenanceName_maybe provenance'))

    {-
    *********************************************************
    *                                                      *
    \subsection{Default declarations}
    *                                                      *
    *********************************************************
    -}

    rnDefaultDecl :: DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars)
    rnDefaultDecl :: DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars)
    rnDefaultDecl (DefaultDecl XCDefaultDecl GhcPs
    _ [LHsType GhcPs]
    tys)
      = do { (tys', fvs) <- HsDocContext -> [LHsType GhcPs] -> RnM ([LHsType GhcRn], FreeVars)
    rnLHsTypes HsDocContext
    doc_str [LHsType GhcPs]
    tys
           ; return (DefaultDecl noExtField tys', fvs) }
      where
        doc_str :: HsDocContext
    doc_str = HsDocContext
    DefaultDeclCtx

    {-
    *********************************************************
    *                                                      *
    \subsection{Foreign declarations}
    *                                                      *
    *********************************************************
    -}

    rnHsForeignDecl :: ForeignDecl GhcPs -> RnM (ForeignDecl GhcRn, FreeVars)
    rnHsForeignDecl :: ForeignDecl GhcPs -> RnM (ForeignDecl GhcRn, FreeVars)
    rnHsForeignDecl (ForeignImport { fd_name :: forall pass. ForeignDecl pass -> LIdP pass
    fd_name = LIdP GhcPs
    name, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
    fd_sig_ty = LHsSigType GhcPs
    ty, fd_fi :: forall pass. ForeignDecl pass -> ForeignImport pass
    fd_fi = ForeignImport GhcPs
    spec })
      = do { topEnv :: HscEnv <- TcRnIf TcGblEnv TcLclEnv HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
           ; name' <- lookupLocatedTopBndrRnN name
           ; (ty', fvs) <- rnHsSigType (ForeignDeclCtx name) TypeLevel ty

            -- Mark any PackageTarget style imports as coming from the current package
           ; let home_unit = HscEnv -> HomeUnit
    hsc_home_unit HscEnv
    topEnv
                 spec'  = Unit -> ForeignImport GhcPs -> ForeignImport GhcRn
    patchForeignImport (HomeUnit -> Unit
    homeUnitAsUnit HomeUnit
    home_unit) ForeignImport GhcPs
    spec

           ; return (ForeignImport { fd_i_ext = noExtField
                                   , fd_name = name', fd_sig_ty = ty'
                                   , fd_fi = spec' }, fvs) }

    rnHsForeignDecl (ForeignExport { fd_name :: forall pass. ForeignDecl pass -> LIdP pass
    fd_name = LIdP GhcPs
    name, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
    fd_sig_ty = LHsSigType GhcPs
    ty, fd_fe :: forall pass. ForeignDecl pass -> ForeignExport pass
    fd_fe = ForeignExport GhcPs
    spec })
      = do { name' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    forall ann.
    GenLocated (EpAnn ann) RdrName
    -> TcRn (GenLocated (EpAnn ann) Name)
    lookupLocatedOccRn LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    name
           ; (ty', fvs) <- rnHsSigType (ForeignDeclCtx name) TypeLevel ty
           ; return (ForeignExport { fd_e_ext = noExtField
                                   , fd_name = name', fd_sig_ty = ty'
                                   , fd_fe = (\(CExport XCExport GhcPs
    x XRec GhcPs CExportSpec
    c) -> XCExport GhcRn -> XRec GhcRn CExportSpec -> ForeignExport GhcRn
    forall pass.
    XCExport pass -> XRec pass CExportSpec -> ForeignExport pass
    CExport XCExport GhcPs
    XCExport GhcRn
    x XRec GhcPs CExportSpec
    XRec GhcRn CExportSpec
    c) spec }
                    , fvs `addOneFV` unLoc name') }
            -- NB: a foreign export is an *occurrence site* for name, so
            --     we add it to the free-variable list.  It might, for example,
            --     be imported from another module

    -- | For Windows DLLs we need to know what packages imported symbols are from
    --      to generate correct calls. Imported symbols are tagged with the current
    --      package, so if they get inlined across a package boundary we'll still
    --      know where they're from.
    --
    patchForeignImport :: Unit -> (ForeignImport GhcPs) -> (ForeignImport GhcRn)
    patchForeignImport :: Unit -> ForeignImport GhcPs -> ForeignImport GhcRn
    patchForeignImport Unit
    unit (CImport XCImport GhcPs
    ext XRec GhcPs CCallConv
    cconv XRec GhcPs Safety
    safety Maybe Header
    fs CImportSpec
    spec)
            = XCImport GhcRn
    -> XRec GhcRn CCallConv
    -> XRec GhcRn Safety
    -> Maybe Header
    -> CImportSpec
    -> ForeignImport GhcRn
    forall pass.
    XCImport pass
    -> XRec pass CCallConv
    -> XRec pass Safety
    -> Maybe Header
    -> CImportSpec
    -> ForeignImport pass
    CImport XCImport GhcPs
    XCImport GhcRn
    ext XRec GhcPs CCallConv
    XRec GhcRn CCallConv
    cconv XRec GhcPs Safety
    XRec GhcRn Safety
    safety Maybe Header
    fs (Unit -> CImportSpec -> CImportSpec
    patchCImportSpec Unit
    unit CImportSpec
    spec)

    patchCImportSpec :: Unit -> CImportSpec -> CImportSpec
    patchCImportSpec :: Unit -> CImportSpec -> CImportSpec
    patchCImportSpec Unit
    unit CImportSpec
    spec
     = case CImportSpec
    spec of
            CFunction CCallTarget
    callTarget    -> CCallTarget -> CImportSpec
    CFunction (CCallTarget -> CImportSpec) -> CCallTarget -> CImportSpec
    forall a b. (a -> b) -> a -> b
    $ Unit -> CCallTarget -> CCallTarget
    patchCCallTarget Unit
    unit CCallTarget
    callTarget
            CImportSpec
    _                       -> CImportSpec
    spec

    patchCCallTarget :: Unit -> CCallTarget -> CCallTarget
    patchCCallTarget :: Unit -> CCallTarget -> CCallTarget
    patchCCallTarget Unit
    unit CCallTarget
    callTarget =
      case CCallTarget
    callTarget of
      StaticTarget SourceText
    src CLabelString
    label Maybe Unit
    Nothing Bool
    isFun
                                  -> SourceText -> CLabelString -> Maybe Unit -> Bool -> CCallTarget
    StaticTarget SourceText
    src CLabelString
    label (Unit -> Maybe Unit
    forall a. a -> Maybe a
    Just Unit
    unit) Bool
    isFun
      CCallTarget
    _                           -> CCallTarget
    callTarget

    {-
    *********************************************************
    *                                                      *
    \subsection{Instance declarations}
    *                                                      *
    *********************************************************
    -}

    rnSrcInstDecl :: InstDecl GhcPs -> RnM (InstDecl GhcRn, FreeVars)
    rnSrcInstDecl :: InstDecl GhcPs -> RnM (InstDecl GhcRn, FreeVars)
    rnSrcInstDecl (TyFamInstD { tfid_inst :: forall pass. InstDecl pass -> TyFamInstDecl pass
    tfid_inst = TyFamInstDecl GhcPs
    tfi })
      = do { (tfi', fvs) <- AssocTyFamInfo
    -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
    rnTyFamInstDecl (ClosedTyFamInfo -> AssocTyFamInfo
    NonAssocTyFamEqn ClosedTyFamInfo
    NotClosedTyFam) TyFamInstDecl GhcPs
    tfi
           ; return (TyFamInstD { tfid_ext = noExtField, tfid_inst = tfi' }, fvs) }

    rnSrcInstDecl (DataFamInstD { dfid_inst :: forall pass. InstDecl pass -> DataFamInstDecl pass
    dfid_inst = DataFamInstDecl GhcPs
    dfi })
      = do { (dfi', fvs) <- AssocTyFamInfo
    -> DataFamInstDecl GhcPs -> RnM (DataFamInstDecl GhcRn, FreeVars)
    rnDataFamInstDecl (ClosedTyFamInfo -> AssocTyFamInfo
    NonAssocTyFamEqn ClosedTyFamInfo
    NotClosedTyFam) DataFamInstDecl GhcPs
    dfi
           ; return (DataFamInstD { dfid_ext = noExtField, dfid_inst = dfi' }, fvs) }

    rnSrcInstDecl (ClsInstD { cid_inst :: forall pass. InstDecl pass -> ClsInstDecl pass
    cid_inst = ClsInstDecl GhcPs
    cid })
      = do { String -> SDoc -> TcRn ()
    traceRn String
    "rnSrcIstDecl {" (ClsInstDecl GhcPs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ClsInstDecl GhcPs
    cid)
           ; (cid', fvs) <- ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
    rnClsInstDecl ClsInstDecl GhcPs
    cid
           ; traceRn "rnSrcIstDecl end }" empty
           ; return (ClsInstD { cid_d_ext = noExtField, cid_inst = cid' }, fvs) }

    -- | Warn about non-canonical typeclass instance declarations
    --
    -- A "non-canonical" instance definition can occur for instances of a
    -- class which redundantly defines an operation its superclass
    -- provides as well (c.f. `return`/`pure`). In such cases, a canonical
    -- instance is one where the subclass inherits its method
    -- implementation from its superclass instance (usually the subclass
    -- has a default method implementation to that effect). Consequently,
    -- a non-canonical instance occurs when this is not the case.
    --
    -- See also descriptions of 'checkCanonicalMonadInstances' and
    -- 'checkCanonicalMonoidInstances'
    checkCanonicalInstances :: Name -> LHsSigType GhcRn -> LHsBinds GhcRn -> RnM ()
    checkCanonicalInstances :: Name -> LHsSigType GhcRn -> LHsBinds GhcRn -> TcRn ()
    checkCanonicalInstances Name
    cls LHsSigType GhcRn
    poly_ty LHsBinds GhcRn
    mbinds = do
        WarningFlag -> TcRn () -> TcRn ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnNonCanonicalMonadInstances
            (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRn ()
    checkCanonicalMonadInstances

        WarningFlag -> TcRn () -> TcRn ()
    forall gbl lcl.
    WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    whenWOptM WarningFlag
    Opt_WarnNonCanonicalMonoidInstances
            (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRn ()
    checkCanonicalMonoidInstances

      where
        -- Warn about unsound/non-canonical 'Applicative'/'Monad' instance
        -- declarations. Specifically, the following conditions are verified:
        --
        -- In 'Monad' instances declarations:
        --
        --  * If 'return' is overridden it must be canonical (i.e. @return = pure@)
        --  * If '(>>)' is overridden it must be canonical (i.e. @(>>) = (*>)@)
        --
        -- In 'Applicative' instance declarations:
        --
        --  * Warn if 'pure' is defined backwards (i.e. @pure = return@).
        --  * Warn if '(*>)' is defined backwards (i.e. @(*>) = (>>)@).
        --
        checkCanonicalMonadInstances :: TcRn ()
    checkCanonicalMonadInstances
          | Name
    cls Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    applicativeClassName =
              [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    -> [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    forall a. Bag a -> [a]
    bagToList LHsBinds GhcRn
    Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    mbinds) ((GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
     -> TcRn ())
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ \(L SrcSpanAnnA
    loc HsBindLR GhcRn GhcRn
    mbind) -> SrcSpanAnnA -> TcRn () -> TcRn ()
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                  case HsBindLR GhcRn GhcRn
    mbind of
                      FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
    fun_id = L SrcSpanAnnN
    _ Name
    name
                              , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
    fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
    mg }
                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    pureAName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    returnMName
                          -> NonCanonical_Monad -> TcRn ()
    addWarnNonCanonicalMonad NonCanonical_Monad
    NonCanonical_Pure

                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    thenAName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    thenMName
                          -> NonCanonical_Monad -> TcRn ()
    addWarnNonCanonicalMonad NonCanonical_Monad
    NonCanonical_ThenA

                      HsBindLR GhcRn GhcRn
    _ -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

          | Name
    cls Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    monadClassName =
              [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    -> [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    forall a. Bag a -> [a]
    bagToList LHsBinds GhcRn
    Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    mbinds) ((GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
     -> TcRn ())
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ \(L SrcSpanAnnA
    loc HsBindLR GhcRn GhcRn
    mbind) -> SrcSpanAnnA -> TcRn () -> TcRn ()
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                  case HsBindLR GhcRn GhcRn
    mbind of
                      FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
    fun_id = L SrcSpanAnnN
    _ Name
    name
                              , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
    fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
    mg }
                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    returnMName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    pureAName
                          -> NonCanonical_Monad -> TcRn ()
    addWarnNonCanonicalMonad NonCanonical_Monad
    NonCanonical_Return

                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    thenMName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    thenAName
                          -> NonCanonical_Monad -> TcRn ()
    addWarnNonCanonicalMonad NonCanonical_Monad
    NonCanonical_ThenM

                      HsBindLR GhcRn GhcRn
    _ -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

          | Bool
    otherwise = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

        -- Check whether Monoid(mappend) is defined in terms of
        -- Semigroup((<>)) (and not the other way round). Specifically,
        -- the following conditions are verified:
        --
        -- In 'Monoid' instances declarations:
        --
        --  * If 'mappend' is overridden it must be canonical
        --    (i.e. @mappend = (<>)@)
        --
        -- In 'Semigroup' instance declarations:
        --
        --  * Warn if '(<>)' is defined backwards (i.e. @(<>) = mappend@).
        --
        checkCanonicalMonoidInstances :: TcRn ()
    checkCanonicalMonoidInstances
          | Name
    cls Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    semigroupClassName =
              [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    -> [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    forall a. Bag a -> [a]
    bagToList LHsBinds GhcRn
    Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    mbinds) ((GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
     -> TcRn ())
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ \(L SrcSpanAnnA
    loc HsBindLR GhcRn GhcRn
    mbind) -> SrcSpanAnnA -> TcRn () -> TcRn ()
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                  case HsBindLR GhcRn GhcRn
    mbind of
                      FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
    fun_id      = L SrcSpanAnnN
    _ Name
    name
                              , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
    fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
    mg }
                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    sappendName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    mappendName
                          -> NonCanonical_Monoid -> TcRn ()
    addWarnNonCanonicalMonoid NonCanonical_Monoid
    NonCanonical_Sappend

                      HsBindLR GhcRn GhcRn
    _ -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

          | Name
    cls Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    monoidClassName =
              [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    -> [GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn)]
    forall a. Bag a -> [a]
    bagToList LHsBinds GhcRn
    Bag (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn))
    mbinds) ((GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
     -> TcRn ())
    -> (GenLocated SrcSpanAnnA (HsBindLR GhcRn GhcRn) -> TcRn ())
    -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ \(L SrcSpanAnnA
    loc HsBindLR GhcRn GhcRn
    mbind) -> SrcSpanAnnA -> TcRn () -> TcRn ()
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                  case HsBindLR GhcRn GhcRn
    mbind of
                      FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
    fun_id = L SrcSpanAnnN
    _ Name
    name
                              , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
    fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
    mg }
                          | Name
    name Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name
    mappendName, MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    mg Maybe Name -> Maybe Name -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    sappendName
                          -> NonCanonical_Monoid -> TcRn ()
    addWarnNonCanonicalMonoid NonCanonical_Monoid
    NonCanonical_Mappend

                      HsBindLR GhcRn GhcRn
    _ -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

          | Bool
    otherwise = () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

        -- test whether MatchGroup represents a trivial \"lhsName = rhsName\"
        -- binding, and return @Just rhsName@ if this is the case
        isAliasMG :: MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
        isAliasMG :: MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name
    isAliasMG MG {mg_alts :: forall p body. MatchGroup p body -> XRec p [LMatch p body]
    mg_alts = (L SrcSpanAnnL
    _ [L SrcSpanAnnA
    _ (Match { m_pats :: forall p body. Match p body -> [LPat p]
    m_pats = []
                                                 , m_grhss :: forall p body. Match p body -> GRHSs p body
    m_grhss = GRHSs GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
    grhss })])}
            | GRHSs XCGRHSs GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
    _ [L EpAnnCO
    _ (GRHS XCGRHS GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
    _ [] GenLocated SrcSpanAnnA (HsExpr GhcRn)
    body)] HsLocalBinds GhcRn
    lbinds <- GRHSs GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
    grhss
            , EmptyLocalBinds XEmptyLocalBinds GhcRn GhcRn
    _ <- HsLocalBinds GhcRn
    lbinds
            , HsVar XVar GhcRn
    _ LIdP GhcRn
    lrhsName  <- GenLocated SrcSpanAnnA (HsExpr GhcRn) -> HsExpr GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnA (HsExpr GhcRn)
    body  = Name -> Maybe Name
    forall a. a -> Maybe a
    Just (GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LIdP GhcRn
    GenLocated SrcSpanAnnN Name
    lrhsName)
        isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
    _ = Maybe Name
    forall a. Maybe a
    Nothing

        addWarnNonCanonicalMonoid :: NonCanonical_Monoid -> TcRn ()
    addWarnNonCanonicalMonoid NonCanonical_Monoid
    reason =
          NonCanonicalDefinition -> TcRn ()
    addWarnNonCanonicalDefinition (NonCanonical_Monoid -> NonCanonicalDefinition
    NonCanonicalMonoid NonCanonical_Monoid
    reason)

        addWarnNonCanonicalMonad :: NonCanonical_Monad -> TcRn ()
    addWarnNonCanonicalMonad NonCanonical_Monad
    reason =
          NonCanonicalDefinition -> TcRn ()
    addWarnNonCanonicalDefinition (NonCanonical_Monad -> NonCanonicalDefinition
    NonCanonicalMonad NonCanonical_Monad
    reason)

        addWarnNonCanonicalDefinition :: NonCanonicalDefinition -> TcRn ()
    addWarnNonCanonicalDefinition NonCanonicalDefinition
    reason =
          TcRnMessage -> TcRn ()
    addDiagnostic (NonCanonicalDefinition -> LHsSigType GhcRn -> TcRnMessage
    TcRnNonCanonicalDefinition NonCanonicalDefinition
    reason LHsSigType GhcRn
    poly_ty)

    rnClsInstDecl :: ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
    rnClsInstDecl :: ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
    rnClsInstDecl (ClsInstDecl { cid_ext :: forall pass. ClsInstDecl pass -> XCClsInstDecl pass
    cid_ext = (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    inst_warn_ps, [AddEpAnn]
    _, AnnSortKey DeclTag
    _)
                               , cid_poly_ty :: forall pass. ClsInstDecl pass -> LHsSigType pass
    cid_poly_ty = LHsSigType GhcPs
    inst_ty, cid_binds :: forall pass. ClsInstDecl pass -> LHsBinds pass
    cid_binds = LHsBinds GhcPs
    mbinds
                               , cid_sigs :: forall pass. ClsInstDecl pass -> [LSig pass]
    cid_sigs = [LSig GhcPs]
    uprags, cid_tyfam_insts :: forall pass. ClsInstDecl pass -> [LTyFamInstDecl pass]
    cid_tyfam_insts = [LTyFamInstDecl GhcPs]
    ats
                               , cid_overlap_mode :: forall pass. ClsInstDecl pass -> Maybe (XRec pass OverlapMode)
    cid_overlap_mode = Maybe (XRec GhcPs OverlapMode)
    oflag
                               , cid_datafam_insts :: forall pass. ClsInstDecl pass -> [LDataFamInstDecl pass]
    cid_datafam_insts = [LDataFamInstDecl GhcPs]
    adts })
      = do { HsDocContext -> LHsSigType GhcPs -> TcRn ()
    checkInferredVars HsDocContext
    ctxt LHsSigType GhcPs
    inst_ty
           ; (inst_ty', inst_fvs) <- HsDocContext
    -> TypeOrKind
    -> LHsSigType GhcPs
    -> RnM (LHsSigType GhcRn, FreeVars)
    rnHsSigType HsDocContext
    ctxt TypeOrKind
    TypeLevel LHsSigType GhcPs
    inst_ty
           ; let (ktv_names, _, head_ty') = splitLHsInstDeclTy inst_ty'
                 -- Check if there are any nested `forall`s or contexts, which are
                 -- illegal in the type of an instance declaration (see
                 -- Note [No nested foralls or contexts in instance types] in
                 -- GHC.Hs.Type)...
                 mb_nested_msg = NestedForallsContextsIn
    -> LHsType GhcRn -> Maybe (SrcSpan, TcRnMessage)
    noNestedForallsContextsErr
                                   NestedForallsContextsIn
    NFC_InstanceHead LHsType GhcRn
    head_ty'
                 -- ...then check if the instance head is actually headed by a
                 -- class type constructor...
                 eith_cls = case LHsType GhcRn -> Maybe (LocatedN (IdP GhcRn))
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    LHsType (GhcPass p) -> Maybe (LocatedN (IdP (GhcPass p)))
    hsTyGetAppHead_maybe LHsType GhcRn
    head_ty' of
                   Just (L SrcSpanAnnN
    _ IdP GhcRn
    cls) -> Name -> Either (SrcSpan, TcRnMessage) Name
    forall a b. b -> Either a b
    Right IdP GhcRn
    Name
    cls
                   Maybe (LocatedN (IdP GhcRn))
    Nothing        ->
                      (SrcSpan, TcRnMessage) -> Either (SrcSpan, TcRnMessage) Name
    forall a b. a -> Either a b
    Left
                       ( GenLocated SrcSpanAnnA (HsType GhcRn) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    head_ty'
                       , IllegalInstanceReason -> TcRnMessage
    TcRnIllegalInstance (IllegalInstanceReason -> TcRnMessage)
    -> IllegalInstanceReason -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $
                           TypedThing -> IllegalClassInstanceReason -> IllegalInstanceReason
    IllegalClassInstance (HsType GhcRn -> TypedThing
    HsTypeRnThing (HsType GhcRn -> TypedThing) -> HsType GhcRn -> TypedThing
    forall a b. (a -> b) -> a -> b
    $ GenLocated SrcSpanAnnA (HsType GhcRn) -> HsType GhcRn
    forall l e. GenLocated l e -> e
    unLoc LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    head_ty') (IllegalClassInstanceReason -> IllegalInstanceReason)
    -> IllegalClassInstanceReason -> IllegalInstanceReason
    forall a b. (a -> b) -> a -> b
    $
                           IllegalInstanceHeadReason -> IllegalClassInstanceReason
    IllegalInstanceHead (IllegalInstanceHeadReason -> IllegalClassInstanceReason)
    -> IllegalInstanceHeadReason -> IllegalClassInstanceReason
    forall a b. (a -> b) -> a -> b
    $ Maybe TyCon -> IllegalInstanceHeadReason
    InstHeadNonClass Maybe TyCon
    forall a. Maybe a
    Nothing
                       )
             -- ...finally, attempt to retrieve the class type constructor, failing
             -- with an error message if there isn't one. To avoid excessive
             -- amounts of error messages, we will only report one of the errors
             -- from mb_nested_msg or eith_cls at a time.
           ; cls <- case (mb_nested_msg, eith_cls) of
               (Maybe (SrcSpan, TcRnMessage)
    Nothing,   Right Name
    cls) -> Name -> IOEnv (Env TcGblEnv TcLclEnv) Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    cls
               (Just (SrcSpan, TcRnMessage)
    err1, Either (SrcSpan, TcRnMessage) Name
    _)         -> (SrcSpan, TcRnMessage) -> IOEnv (Env TcGblEnv TcLclEnv) Name
    bail_out (SrcSpan, TcRnMessage)
    err1
               (Maybe (SrcSpan, TcRnMessage)
    _,         Left (SrcSpan, TcRnMessage)
    err2) -> (SrcSpan, TcRnMessage) -> IOEnv (Env TcGblEnv TcLclEnv) Name
    bail_out (SrcSpan, TcRnMessage)
    err2

              -- Rename the bindings
              -- The typechecker (not the renamer) checks that all
              -- the bindings are for the right class
              -- (Slightly strangely) when scoped type variables are on, the
              -- forall-d tyvars scope over the method bindings too
           ; (mbinds', uprags', meth_fvs) <- rnMethodBinds False cls ktv_names mbinds uprags

           ; checkCanonicalInstances cls inst_ty' mbinds'

           -- Rename the associated types, and type signatures
           -- Both need to have the instance type variables in scope
           ; traceRn "rnSrcInstDecl" (ppr inst_ty' $$ ppr ktv_names)
           ; ((ats', adts'), more_fvs)
                 <- bindLocalNamesFV ktv_names $
                    do { (ats',  at_fvs)  <- rnATInstDecls rnTyFamInstDecl cls ktv_names ats
                       ; (adts', adt_fvs) <- rnATInstDecls rnDataFamInstDecl cls ktv_names adts
                       ; return ( (ats', adts'), at_fvs `plusFV` adt_fvs) }

           ; let all_fvs = FreeVars
    meth_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    more_fvs
                                    FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    inst_fvs
           ; inst_warn_rn <- mapM rnLWarningTxt inst_warn_ps
           ; return (ClsInstDecl { cid_ext = inst_warn_rn
                                 , cid_poly_ty = inst_ty', cid_binds = mbinds'
                                 , cid_sigs = uprags', cid_tyfam_insts = ats'
                                 , cid_overlap_mode = oflag
                                 , cid_datafam_insts = adts' },
                     all_fvs) }
                 -- We return the renamed associated data type declarations so
                 -- that they can be entered into the list of type declarations
                 -- for the binding group, but we also keep a copy in the instance.
                 -- The latter is needed for well-formedness checks in the type
                 -- checker (eg, to ensure that all ATs of the instance actually
                 -- receive a declaration).
                 -- NB: Even the copies in the instance declaration carry copies of
                 --     the instance context after renaming.  This is a bit
                 --     strange, but should not matter (and it would be more work
                 --     to remove the context).
      where
        ctxt :: HsDocContext
    ctxt    = SDoc -> HsDocContext
    GenericCtx (SDoc -> HsDocContext) -> SDoc -> HsDocContext
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "an instance declaration"

        -- The instance is malformed. We'd still like to make *some* progress
        -- (rather than failing outright), so we report an error and continue for
        -- as long as we can. Importantly, this error should be thrown before we
        -- reach the typechecker, lest we encounter different errors that are
        -- hopelessly confusing (such as the one in #16114).
        bail_out :: (SrcSpan, TcRnMessage) -> IOEnv (Env TcGblEnv TcLclEnv) Name
    bail_out (SrcSpan
    l, TcRnMessage
    err_msg) = do
          SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt SrcSpan
    l (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ HsDocContext -> TcRnMessage -> TcRnMessage
    TcRnWithHsDocContext HsDocContext
    ctxt TcRnMessage
    err_msg
          Name -> IOEnv (Env TcGblEnv TcLclEnv) Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Name -> IOEnv (Env TcGblEnv TcLclEnv) Name)
    -> Name -> IOEnv (Env TcGblEnv TcLclEnv) Name
    forall a b. (a -> b) -> a -> b
    $ OccName -> Name
    mkUnboundName (CLabelString -> OccName
    mkTcOccFS (String -> CLabelString
    fsLit String
    "<class>"))

    rnFamEqn :: HsDocContext
             -> AssocTyFamInfo
             -> FamEqn GhcPs rhs
             -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
             -> RnM (FamEqn GhcRn rhs', FreeVars)
    rnFamEqn :: forall rhs rhs'.
    HsDocContext
    -> AssocTyFamInfo
    -> FamEqn GhcPs rhs
    -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
    -> RnM (FamEqn GhcRn rhs', FreeVars)
    rnFamEqn HsDocContext
    doc AssocTyFamInfo
    atfi
        (FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon  = LIdP GhcPs
    tycon
                , feqn_bndrs :: forall pass rhs. FamEqn pass rhs -> HsOuterFamEqnTyVarBndrs pass
    feqn_bndrs  = HsOuterFamEqnTyVarBndrs GhcPs
    outer_bndrs
                , feqn_pats :: forall pass rhs. FamEqn pass rhs -> HsFamEqnPats pass
    feqn_pats   = HsFamEqnPats GhcPs
    pats
                , feqn_fixity :: forall pass rhs. FamEqn pass rhs -> LexicalFixity
    feqn_fixity = LexicalFixity
    fixity
                , feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
    feqn_rhs    = rhs
    payload }) HsDocContext -> rhs -> RnM (rhs', FreeVars)
    rn_payload
      = do { tycon' <- Maybe Name
    -> GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupFamInstName Maybe Name
    mb_cls LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon

             -- all_imp_vars represent the implicitly bound type variables. This is
             -- empty if we have an explicit `forall` (see
             -- Note [forall-or-nothing rule] in GHC.Hs.Type), which means
             -- ignoring pat_kity_vars, the free variables mentioned in the type patterns
             -- on the LHS of the equation
             --
             -- Some examples:
             --
             -- @
             -- type family F a b
             -- type instance forall a b c. F [(a, b)] c = a -> b -> c
             --   -- all_imp_vars = []
             -- type instance F [(a, b)] c = a -> b -> c
             --   -- all_imp_vars = [a, b, c]
             --
             -- type family G :: Maybe a
             -- type instance forall a. G = (Nothing :: Maybe a)
             --   -- all_imp_vars = []
             --
             -- data family H :: k -> Type
             -- data instance forall k. H :: k -> Type where ...
             --   -- all_imp_vars = []
             -- data instance H :: k -> Type where ...
             --   -- all_imp_vars = [k]
             -- @
             --
             -- For associated type family instances, exclude the type variables
             -- bound by the instance head with filterInScopeM (#19649).
           ; all_imp_vars <- filterInScopeM $ pat_kity_vars

           ; bindHsOuterTyVarBndrs doc mb_cls all_imp_vars outer_bndrs $ \HsOuterTyVarBndrs () GhcRn
    rn_outer_bndrs ->
        do { (pats', pat_fvs) <- HsDocContext
    -> HsFamEqnPats GhcPs -> RnM ([LHsTypeArg GhcRn], FreeVars)
    rnLHsTypeArgs (GenLocated SrcSpanAnnN RdrName -> HsDocContext
    FamPatCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon) HsFamEqnPats GhcPs
    pats
           ; (payload', rhs_fvs) <- rn_payload doc payload

              -- Report unused binders on the LHS
              -- See Note [Unused type variables in family instances]
           ; let -- The SrcSpan that bindHsOuterFamEqnTyVarBndrs will attach to each
                 -- implicitly bound type variable Name in outer_bndrs' will
                 -- span the entire type family instance, which will be reflected in
                 -- -Wunused-type-patterns warnings. We can be a little more precise
                 -- than that by pointing to the LHS of the instance instead, which
                 -- is what lhs_loc corresponds to.
                 rn_outer_bndrs' = (XHsOuterImplicit GhcRn -> XHsOuterImplicit GhcRn)
    -> HsOuterTyVarBndrs () GhcRn -> HsOuterTyVarBndrs () GhcRn
    forall pass flag.
    (XHsOuterImplicit pass -> XHsOuterImplicit pass)
    -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass
    mapHsOuterImplicit ((Name -> Name) -> [Name] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (Name -> SrcSpan -> Name
    `setNameLoc` SrcSpan
    lhs_loc))
                                                      HsOuterTyVarBndrs () GhcRn
    rn_outer_bndrs

                 groups :: [NonEmpty (LocatedN RdrName)]
                 groups = (GenLocated SrcSpanAnnN RdrName
     -> GenLocated SrcSpanAnnN RdrName -> Ordering)
    -> FreeKiTyVars -> [NonEmpty (GenLocated SrcSpanAnnN RdrName)]
    forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
    equivClasses GenLocated SrcSpanAnnN RdrName
    -> GenLocated SrcSpanAnnN RdrName -> Ordering
    forall a l. Ord a => GenLocated l a -> GenLocated l a -> Ordering
    cmpLocated FreeKiTyVars
    pat_kity_vars
           ; nms_dups <- mapM (lookupOccRn . unLoc) $
                            [ tv | (tv :| (_:_)) <- groups ]
                 -- Add to the used variables
                 --  a) any variables that appear *more than once* on the LHS
                 --     e.g.   F a Int a = Bool
                 --  b) for associated instances, the variables
                 --     of the instance decl.  See
                 --     Note [Unused type variables in family instances]
           ; let nms_used = FreeVars -> [Name] -> FreeVars
    extendNameSetList FreeVars
    rhs_fvs ([Name] -> FreeVars) -> [Name] -> FreeVars
    forall a b. (a -> b) -> a -> b
    $
                               [Name]
    nms_dups {- (a) -} [Name] -> [Name] -> [Name]
    forall a. [a] -> [a] -> [a]
    ++ [Name]
    inst_head_tvs {- (b) -}
                 all_nms = HsOuterTyVarBndrs () GhcRn -> [Name]
    forall flag. HsOuterTyVarBndrs flag GhcRn -> [Name]
    hsOuterTyVarNames HsOuterTyVarBndrs () GhcRn
    rn_outer_bndrs'
           ; warnUnusedTypePatterns all_nms nms_used

             -- For associated family instances, if a type variable from the
             -- parent instance declaration is mentioned on the RHS of the
             -- associated family instance but not bound on the LHS, then reject
             -- that type variable as being out of scope.
             -- See Note [Renaming associated types].
             -- Per that Note, the LHS type variables consist of the variables
             -- mentioned in the instance's type patterns (pat_fvs)
           ; let improperly_scoped Name
    cls_tkv =
                      Name
    cls_tkv Name -> FreeVars -> Bool
    `elemNameSet` FreeVars
    rhs_fvs
                        -- Mentioned on the RHS...
                   Bool -> Bool -> Bool
    && Bool -> Bool
    not (Name
    cls_tkv Name -> FreeVars -> Bool
    `elemNameSet` FreeVars
    pat_fvs)
                        -- ...but not bound on the LHS.
                 bad_tvs = (Name -> Bool) -> [Name] -> [Name]
    forall a. (a -> Bool) -> [a] -> [a]
    filter Name -> Bool
    improperly_scoped [Name]
    inst_head_tvs
           ; for_ (nonEmpty bad_tvs) $ \ NonEmpty Name
    ne_bad_tvs ->
               TcRnMessage -> TcRn ()
    addErr (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
               IllegalInstanceReason -> TcRnMessage
    TcRnIllegalInstance (IllegalInstanceReason -> TcRnMessage)
    -> IllegalInstanceReason -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ IllegalFamilyInstanceReason -> IllegalInstanceReason
    IllegalFamilyInstance (IllegalFamilyInstanceReason -> IllegalInstanceReason)
    -> IllegalFamilyInstanceReason -> IllegalInstanceReason
    forall a b. (a -> b) -> a -> b
    $
                 Maybe (TyCon, [Type], TyVarSet)
    -> NonEmpty Name -> IllegalFamilyInstanceReason
    FamInstRHSOutOfScopeTyVars Maybe (TyCon, [Type], TyVarSet)
    forall a. Maybe a
    Nothing NonEmpty Name
    ne_bad_tvs

           ; let eqn_fvs = FreeVars
    rhs_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    pat_fvs
                 -- See Note [Type family equations and occurrences]
                 all_fvs = case AssocTyFamInfo
    atfi of
                             NonAssocTyFamEqn ClosedTyFamInfo
    ClosedTyFam
                               -> FreeVars
    eqn_fvs
                             AssocTyFamInfo
    _ -> FreeVars
    eqn_fvs FreeVars -> Name -> FreeVars
    `addOneFV` GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnN Name
    tycon'

           ; return (FamEqn { feqn_ext    = noAnn
                            , feqn_tycon  = tycon'
                              -- Note [Wildcards in family instances]
                            , feqn_bndrs  = rn_outer_bndrs'
                            , feqn_pats   = pats'
                            , feqn_fixity = fixity
                            , feqn_rhs    = payload' },
                     all_fvs) } }
      where
        -- The parent class, if we are dealing with an associated type family
        -- instance.
        mb_cls :: Maybe Name
    mb_cls = case AssocTyFamInfo
    atfi of
          NonAssocTyFamEqn ClosedTyFamInfo
    _   -> Maybe Name
    forall a. Maybe a
    Nothing
          AssocTyFamDeflt Name
    cls  -> Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    cls
          AssocTyFamInst Name
    cls [Name]
    _ -> Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    cls

        -- The type variables from the instance head, if we are dealing with an
        -- associated type family instance.
        inst_head_tvs :: [Name]
    inst_head_tvs = case AssocTyFamInfo
    atfi of
          NonAssocTyFamEqn ClosedTyFamInfo
    _             -> []
          AssocTyFamDeflt Name
    _              -> []
          AssocTyFamInst Name
    _ [Name]
    inst_head_tvs -> [Name]
    inst_head_tvs

        pat_kity_vars :: FreeKiTyVars
    pat_kity_vars = HsFamEqnPats GhcPs -> FreeKiTyVars
    extractHsTyArgRdrKiTyVars HsFamEqnPats GhcPs
    pats
                 -- It is crucial that extractHsTyArgRdrKiTyVars return
                 -- duplicate occurrences, since they're needed to help
                 -- determine unused binders on the LHS.

        -- The SrcSpan of the LHS of the instance. For example, lhs_loc would be
        -- the highlighted part in the example below:
        --
        --   type instance F a b c = Either a b
        --                   ^^^^^
        lhs_loc :: SrcSpan
    lhs_loc = case (HsArg
       GhcPs
       (GenLocated SrcSpanAnnA (HsType GhcPs))
       (GenLocated SrcSpanAnnA (HsType GhcPs))
     -> SrcSpan)
    -> [HsArg
          GhcPs
          (GenLocated SrcSpanAnnA (HsType GhcPs))
          (GenLocated SrcSpanAnnA (HsType GhcPs))]
    -> [SrcSpan]
    forall a b. (a -> b) -> [a] -> [b]
    map LHsTypeArg GhcPs -> SrcSpan
    HsArg
      GhcPs
      (GenLocated SrcSpanAnnA (HsType GhcPs))
      (GenLocated SrcSpanAnnA (HsType GhcPs))
    -> SrcSpan
    lhsTypeArgSrcSpan HsFamEqnPats GhcPs
    [HsArg
       GhcPs
       (GenLocated SrcSpanAnnA (HsType GhcPs))
       (GenLocated SrcSpanAnnA (HsType GhcPs))]
    pats of
          []         -> String -> SrcSpan
    forall a. HasCallStack => String -> a
    panic String
    "rnFamEqn.lhs_loc"
          [SrcSpan
    loc]      -> SrcSpan
    loc
          (SrcSpan
    loc:[SrcSpan]
    locs) -> SrcSpan
    loc SrcSpan -> SrcSpan -> SrcSpan
    `combineSrcSpans` [SrcSpan] -> SrcSpan
    forall a. HasCallStack => [a] -> a
    last [SrcSpan]
    locs

    rnTyFamInstDecl :: AssocTyFamInfo
                    -> TyFamInstDecl GhcPs
                    -> RnM (TyFamInstDecl GhcRn, FreeVars)
    rnTyFamInstDecl :: AssocTyFamInfo
    -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
    rnTyFamInstDecl AssocTyFamInfo
    atfi (TyFamInstDecl { tfid_xtn :: forall pass. TyFamInstDecl pass -> XCTyFamInstDecl pass
    tfid_xtn = XCTyFamInstDecl GhcPs
    x, tfid_eqn :: forall pass. TyFamInstDecl pass -> TyFamInstEqn pass
    tfid_eqn = TyFamInstEqn GhcPs
    eqn })
      = do { (eqn', fvs) <- AssocTyFamInfo
    -> TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars)
    rnTyFamInstEqn AssocTyFamInfo
    atfi TyFamInstEqn GhcPs
    eqn
           ; return (TyFamInstDecl { tfid_xtn = x, tfid_eqn = eqn' }, fvs) }

    -- | Tracks whether we are renaming:
    --
    -- 1. A type family equation that is not associated
    --    with a parent type class ('NonAssocTyFamEqn'). Examples:
    --
    --    @
    --    type family F a
    --    type instance F Int = Bool  -- NonAssocTyFamEqn NotClosed
    --
    --    type family G a where
    --       G Int = Bool             -- NonAssocTyFamEqn Closed
    --    @
    --
    -- 2. An associated type family default declaration ('AssocTyFamDeflt').
    --    Example:
    --
    --    @
    --    class C a where
    --      type A a
    --      type instance A a = a -> a  -- AssocTyFamDeflt C
    --    @
    --
    -- 3. An associated type family instance declaration ('AssocTyFamInst').
    --    Example:
    --
    --    @
    --    instance C a => C [a] where
    --      type A [a] = Bool  -- AssocTyFamInst C [a]
    --    @
    data AssocTyFamInfo
      = NonAssocTyFamEqn
          ClosedTyFamInfo -- Is this a closed type family?
      | AssocTyFamDeflt
          Name            -- Name of the parent class
      | AssocTyFamInst
          Name            -- Name of the parent class
          [Name]          -- Names of the tyvars of the parent instance decl

    -- | Tracks whether we are renaming an equation in a closed type family
    -- equation ('ClosedTyFam') or not ('NotClosedTyFam').
    data ClosedTyFamInfo
      = NotClosedTyFam
      | ClosedTyFam

    rnTyFamInstEqn :: AssocTyFamInfo
                   -> TyFamInstEqn GhcPs
                   -> RnM (TyFamInstEqn GhcRn, FreeVars)
    rnTyFamInstEqn :: AssocTyFamInfo
    -> TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars)
    rnTyFamInstEqn AssocTyFamInfo
    atfi eqn :: TyFamInstEqn GhcPs
    eqn@(FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon = LIdP GhcPs
    tycon })
      = HsDocContext
    -> AssocTyFamInfo
    -> FamEqn GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))
    -> (HsDocContext
        -> GenLocated SrcSpanAnnA (HsType GhcPs)
        -> RnM (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars))
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (FamEqn GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars)
    forall rhs rhs'.
    HsDocContext
    -> AssocTyFamInfo
    -> FamEqn GhcPs rhs
    -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
    -> RnM (FamEqn GhcRn rhs', FreeVars)
    rnFamEqn (GenLocated SrcSpanAnnN RdrName -> HsDocContext
    TySynCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon) AssocTyFamInfo
    atfi TyFamInstEqn GhcPs
    FamEqn GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))
    eqn HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    HsDocContext
    -> GenLocated SrcSpanAnnA (HsType GhcPs)
    -> RnM (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
    rnTySyn

    rnTyFamDefltDecl :: Name
                     -> TyFamDefltDecl GhcPs
                     -> RnM (TyFamDefltDecl GhcRn, FreeVars)
    rnTyFamDefltDecl :: Name -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
    rnTyFamDefltDecl Name
    cls = AssocTyFamInfo
    -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
    rnTyFamInstDecl (Name -> AssocTyFamInfo
    AssocTyFamDeflt Name
    cls)

    rnDataFamInstDecl :: AssocTyFamInfo
                      -> DataFamInstDecl GhcPs
                      -> RnM (DataFamInstDecl GhcRn, FreeVars)
    rnDataFamInstDecl :: AssocTyFamInfo
    -> DataFamInstDecl GhcPs -> RnM (DataFamInstDecl GhcRn, FreeVars)
    rnDataFamInstDecl AssocTyFamInfo
    atfi (DataFamInstDecl { dfid_eqn :: forall pass. DataFamInstDecl pass -> FamEqn pass (HsDataDefn pass)
    dfid_eqn =
                        eqn :: FamEqn GhcPs (HsDataDefn GhcPs)
    eqn@(FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon = LIdP GhcPs
    tycon })})
      = do { (eqn', fvs) <-
               HsDocContext
    -> AssocTyFamInfo
    -> FamEqn GhcPs (HsDataDefn GhcPs)
    -> (HsDocContext
        -> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars))
    -> RnM (FamEqn GhcRn (HsDataDefn GhcRn), FreeVars)
    forall rhs rhs'.
    HsDocContext
    -> AssocTyFamInfo
    -> FamEqn GhcPs rhs
    -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
    -> RnM (FamEqn GhcRn rhs', FreeVars)
    rnFamEqn (GenLocated SrcSpanAnnN RdrName -> HsDocContext
    TyDataCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon) AssocTyFamInfo
    atfi FamEqn GhcPs (HsDataDefn GhcPs)
    eqn HsDocContext
    -> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars)
    rnDataDefn
           ; return (DataFamInstDecl { dfid_eqn = eqn' }, fvs) }

    -- Renaming of the associated types in instances.

    -- Rename associated type family decl in class
    rnATDecls :: Name      -- Class
              -> [Name]    -- Class variables. See Note [Class variables and filterInScope] in GHC.Rename.HsType
              -> [LFamilyDecl GhcPs]
              -> RnM ([LFamilyDecl GhcRn], FreeVars)
    rnATDecls :: Name
    -> [Name]
    -> [LFamilyDecl GhcPs]
    -> RnM ([LFamilyDecl GhcRn], FreeVars)
    rnATDecls Name
    cls [Name]
    cls_tvs [LFamilyDecl GhcPs]
    at_decls
      = (FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars))
    -> [LocatedA (FamilyDecl GhcPs)]
    -> RnM ([LocatedA (FamilyDecl GhcRn)], FreeVars)
    forall a b.
    (a -> RnM (b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList (Maybe (Name, [Name])
    -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
    rnFamDecl ((Name, [Name]) -> Maybe (Name, [Name])
    forall a. a -> Maybe a
    Just (Name
    cls, [Name]
    cls_tvs))) [LFamilyDecl GhcPs]
    [LocatedA (FamilyDecl GhcPs)]
    at_decls

    rnATInstDecls :: (AssocTyFamInfo ->           -- The function that renames
                      decl GhcPs ->               -- an instance. rnTyFamInstDecl
                      RnM (decl GhcRn, FreeVars)) -- or rnDataFamInstDecl
                  -> Name      -- Class
                  -> [Name]
                  -> [LocatedA (decl GhcPs)]
                  -> RnM ([LocatedA (decl GhcRn)], FreeVars)
    -- Used for data and type family defaults in a class decl
    -- and the family instance declarations in an instance
    --
    -- NB: We allow duplicate associated-type decls;
    --     See Note [Associated type instances] in GHC.Tc.TyCl.Instance
    rnATInstDecls :: forall (decl :: * -> *).
    (AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars))
    -> Name
    -> [Name]
    -> [LocatedA (decl GhcPs)]
    -> RnM ([LocatedA (decl GhcRn)], FreeVars)
    rnATInstDecls AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars)
    rnFun Name
    cls [Name]
    tv_ns [LocatedA (decl GhcPs)]
    at_insts
      = (decl GhcPs -> RnM (decl GhcRn, FreeVars))
    -> [LocatedA (decl GhcPs)]
    -> RnM ([LocatedA (decl GhcRn)], FreeVars)
    forall a b.
    (a -> RnM (b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList (AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars)
    rnFun (Name -> [Name] -> AssocTyFamInfo
    AssocTyFamInst Name
    cls [Name]
    tv_ns)) [LocatedA (decl GhcPs)]
    at_insts
        -- See Note [Renaming associated types]

    {- Note [Wildcards in family instances]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Wild cards can be used in type/data family instance declarations to indicate
    that the name of a type variable doesn't matter. Each wild card will be
    replaced with a new unique type variable. For instance:

        type family F a b :: *
        type instance F Int _ = Int

    is the same as

        type family F a b :: *
        type instance F Int b = Int

    This is implemented as follows: Unnamed wildcards remain unchanged after
    the renamer, and then given fresh meta-variables during typechecking, and
    it is handled pretty much the same way as the ones in partial type signatures.
    We however don't want to emit hole constraints on wildcards in family
    instances, so we turn on PartialTypeSignatures and turn off warning flag to
    let typechecker know this.
    See related Note [Wildcards in visible kind application] in GHC.Tc.Gen.HsType

    Note [Unused type variables in family instances]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When the flag -fwarn-unused-type-patterns is on, the compiler reports
    warnings about unused type variables in type-family instances. A
    tpye variable is considered used (i.e. cannot be turned into a wildcard)
    when

     * it occurs on the RHS of the family instance
       e.g.   type instance F a b = a    -- a is used on the RHS

     * it occurs multiple times in the patterns on the LHS
       e.g.   type instance F a a = Int  -- a appears more than once on LHS

     * it is one of the instance-decl variables, for associated types
       e.g.   instance C (a,b) where
                type T (a,b) = a
       Here the type pattern in the type instance must be the same as that
       for the class instance, so
                type T (a,_) = a
       would be rejected.  So we should not complain about an unused variable b

    As usual, the warnings are not reported for type variables with names
    beginning with an underscore.

    Extra-constraints wild cards are not supported in type/data family
    instance declarations.

    Relevant tickets: #3699, #10586, #10982 and #11451.

    Note [Renaming associated types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When renaming a type/data family instance, be it top-level or associated with
    a class, we must check that all of the type variables mentioned on the RHS are
    properly scoped. Specifically, the rule is this:

      Every variable mentioned on the RHS of a type instance declaration
      (whether associated or not) must be mentioned on the LHS

    Here is a simple example of something we should reject:

      class C a b where
        type F a x
      instance C Int Bool where
        type F Int x = z

    Here, `z` is mentioned on the RHS of the associated instance without being
    mentioned on the LHS. The renamer will reject `z` as being out of scope without much fuss.

    Things get slightly trickier when the instance header itself binds type
    variables. Consider this example (adapted from #5515):

       instance C (p,q) z where
          type F (p,q) x = (x, z)

    According to the rule above, this instance is improperly scoped. However, due
    to the way GHC's renamer works, `z` is /technically/ in scope, as GHC will
    always bring type variables from an instance header into scope over the
    associated type family instances. As a result, the renamer won't simply reject
    the `z` as being out of scope (like it would for the `type F Int x = z`
    example) unless further action is taken. It is important to reject this sort of
    thing in the renamer, because if it is allowed to make it through to the
    typechecker, unexpected shenanigans can occur (see #18021 for examples).

    To prevent these sorts of shenanigans, we reject programs like the one above
    with an extra validity check in rnFamEqn. For each type variable bound in the
    parent instance head, we check if it is mentioned on the RHS of the associated
    family instance but not bound on the LHS. If any of the instance-head-bound
    variables meet these criteria, we throw an error.
    (See rnFamEqn.improperly_scoped for how this is implemented.)

    Some additional wrinkles:

    * This Note only applies to *instance* declarations.  In *class* declarations
      there is no RHS to worry about, and the class variables can all be in scope
      (#5862):

        class Category (x :: k -> k -> *) where
          type Ob x :: k -> Constraint
          id :: Ob x a => x a a
          (.) :: (Ob x a, Ob x b, Ob x c) => x b c -> x a b -> x a c

      Here 'k' is in scope in the kind signature, just like 'x'.

    * Although type family equations can bind type variables with explicit foralls,
      it need not be the case that all variables that appear on the RHS must be
      bound by a forall. For instance, the following is acceptable:

        class C4 a where
          type T4 a b
        instance C4 (Maybe a) where
          type forall b. T4 (Maybe a) b = Either a b

      Even though `a` is not bound by the forall, this is still accepted because `a`
      was previously bound by the `instance C4 (Maybe a)` part. (see #16116).

    * In addition to the validity check in rnFamEqn.improperly_scoped, there is an
      additional check in GHC.Tc.Validity.checkFamPatBinders that checks each family
      instance equation for type variables used on the RHS but not bound on the
      LHS. This is not made redundant by rmFamEqn.improperly_scoped, as there are
      programs that each check will reject that the other check will not catch:

      - checkValidFamPats is used on all forms of family instances, whereas
        rmFamEqn.improperly_scoped only checks associated family instances. Since
        checkFamPatBinders occurs after typechecking, it can catch programs that
        introduce dodgy scoping by way of type synonyms (see #7536), which is
        impractical to accomplish in the renamer.
      - rnFamEqn.improperly_scoped catches some programs that, if allowed to escape
        the renamer, would accidentally be accepted by the typechecker. Here is one
        such program (#18021):

          class C5 a where
            data family D a

          instance forall a. C5 Int where
            data instance D Int = MkD a

        If this is not rejected in the renamer, the typechecker would treat this
        program as though the `a` were existentially quantified, like so:

          data instance D Int = forall a. MkD a

        This is likely not what the user intended!

        Here is another such program (#9574):

          class Funct f where
            type Codomain f
          instance Funct ('KProxy :: KProxy o) where
            type Codomain 'KProxy = NatTr (Proxy :: o -> Type)

        Where:

          data Proxy (a :: k) = Proxy
          data KProxy (t :: Type) = KProxy
          data NatTr (c :: o -> Type)

        Note that the `o` in the `Codomain 'KProxy` instance should be considered
        improperly scoped. It does not meet the criteria for being explicitly
        quantified, as it is not mentioned by name on the LHS.
        However, `o` /is/ bound by the instance header, so if this
        program is not rejected by the renamer, the typechecker would treat it as
        though you had written this:

          instance Funct ('KProxy :: KProxy o) where
            type Codomain ('KProxy @o) = NatTr (Proxy :: o -> Type)

        Although this is a valid program, it's probably a stretch too far to turn
        `type Codomain 'KProxy = ...` into `type Codomain ('KProxy @o) = ...` here.
        If the user really wants the latter, it is simple enough to communicate
        their intent by mentioning `o` on the LHS by name.

    * Historical note: Previously we had to add type variables from the outermost
      kind signature on the RHS to the scope of associated type family instance,
      i.e. GHC did implicit quantification over them. But now that we implement
      GHC Proposal #425 "Invisible binders in type declarations"
      we don't need to do this anymore.

    Note [Type family equations and occurrences]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In most data/type family equations, the type family name used in the equation
    is treated as an occurrence. For example:

      module A where
        type family F a

      module B () where
        import B (F)
        type instance F Int = Bool

    We do not want to warn about `F` being unused in the module `B`, as the
    instance constitutes a use site for `F`. The exception to this rule is closed
    type families, whose equations constitute a definition, not occurrences. For
    example:

      module C () where
        type family CF a where
          CF Char = Float

    Here, we /do/ want to warn that `CF` is unused in the module `C`, as it is
    defined but not used (#18470).

    GHC accomplishes this in rnFamEqn when determining the set of free
    variables to return at the end. If renaming a data family or open type family
    equation, we add the name of the type family constructor to the set of returned
    free variables to ensure that the name is marked as an occurrence. If renaming
    a closed type family equation, we avoid adding the type family constructor name
    to the free variables. This is quite simple, but it is not a perfect solution.
    Consider this example:

      module X () where
        type family F a where
          F Int = Bool
          F Double = F Int

    At present, GHC will treat any use of a type family constructor on the RHS of a
    type family equation as an occurrence. Since `F` is used on the RHS of the
    second equation of `F`, it is treated as an occurrence, causing `F` not to be
    warned about. This is not ideal, since `F` isn't exported—it really /should/
    cause a warning to be emitted. There is some discussion in #10089/#12920 about
    how this limitation might be overcome, but until then, we stick to the
    simplistic solution above, as it fixes the egregious bug in #18470.
    -}

    {-
    *********************************************************
    *                                                      *
    \subsection{Stand-alone deriving declarations}
    *                                                      *
    *********************************************************
    -}

    rnSrcDerivDecl :: DerivDecl GhcPs -> RnM (DerivDecl GhcRn, FreeVars)
    rnSrcDerivDecl :: DerivDecl GhcPs -> RnM (DerivDecl GhcRn, FreeVars)
    rnSrcDerivDecl (DerivDecl (Maybe (GenLocated SrcSpanAnnP (WarningTxt GhcPs))
    inst_warn_ps, [AddEpAnn]
    ann) LHsSigWcType GhcPs
    ty Maybe (LDerivStrategy GhcPs)
    mds Maybe (XRec GhcPs OverlapMode)
    overlap)
      = do { standalone_deriv_ok <- Extension -> TcRn Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.StandaloneDeriving
           ; unless standalone_deriv_ok (addErr TcRnUnexpectedStandaloneDerivingDecl)
           ; checkInferredVars ctxt nowc_ty
           ; (mds', ty', fvs) <- rnLDerivStrategy ctxt mds $ rnHsSigWcType ctxt ty
             -- Check if there are any nested `forall`s or contexts, which are
             -- illegal in the type of an instance declaration (see
             -- Note [No nested foralls or contexts in instance types] in
             -- GHC.Hs.Type).
           ; addNoNestedForallsContextsErr ctxt
               NFC_StandaloneDerivedInstanceHead
               (getLHsInstDeclHead $ dropWildCards ty')
           ; warnNoDerivStrat mds' loc
           ; inst_warn_rn <- mapM rnLWarningTxt inst_warn_ps
           ; return (DerivDecl (inst_warn_rn, ann) ty' mds' overlap, fvs) }
      where
        ctxt :: HsDocContext
    ctxt    = HsDocContext
    DerivDeclCtx
        loc :: SrcSpan
    loc = GenLocated SrcSpanAnnA (HsSigType GhcPs) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LHsSigType GhcPs
    GenLocated SrcSpanAnnA (HsSigType GhcPs)
    nowc_ty
        nowc_ty :: LHsSigType GhcPs
    nowc_ty = LHsSigWcType GhcPs -> LHsSigType GhcPs
    forall pass. LHsSigWcType pass -> LHsSigType pass
    dropWildCards LHsSigWcType GhcPs
    ty

    {-
    *********************************************************
    *                                                      *
    \subsection{Rules}
    *                                                      *
    *********************************************************
    -}

    rnHsRuleDecls :: RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars)
    rnHsRuleDecls :: RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars)
    rnHsRuleDecls (HsRules { rds_ext :: forall pass. RuleDecls pass -> XCRuleDecls pass
    rds_ext = ([AddEpAnn]
    _, SourceText
    src)
                           , rds_rules :: forall pass. RuleDecls pass -> [LRuleDecl pass]
    rds_rules = [LRuleDecl GhcPs]
    rules })
      = do { (rn_rules,fvs) <- (RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars))
    -> [LocatedA (RuleDecl GhcPs)]
    -> RnM ([LocatedA (RuleDecl GhcRn)], FreeVars)
    forall a b.
    (a -> RnM (b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
    rnHsRuleDecl [LRuleDecl GhcPs]
    [LocatedA (RuleDecl GhcPs)]
    rules
           ; return (HsRules { rds_ext = src
                             , rds_rules = rn_rules }, fvs) }

    rnHsRuleDecl :: RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
    rnHsRuleDecl :: RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
    rnHsRuleDecl (HsRule { rd_ext :: forall pass. RuleDecl pass -> XHsRule pass
    rd_ext  = (HsRuleAnn
    _, SourceText
    st)
                         , rd_name :: forall pass. RuleDecl pass -> XRec pass CLabelString
    rd_name = XRec GhcPs CLabelString
    rule_name
                         , rd_act :: forall pass. RuleDecl pass -> Activation
    rd_act  = Activation
    act
                         , rd_tyvs :: forall pass.
    RuleDecl pass -> Maybe [LHsTyVarBndr () (NoGhcTc pass)]
    rd_tyvs = Maybe [LHsTyVarBndr () (NoGhcTc GhcPs)]
    tyvs
                         , rd_tmvs :: forall pass. RuleDecl pass -> [LRuleBndr pass]
    rd_tmvs = [LRuleBndr GhcPs]
    tmvs
                         , rd_lhs :: forall pass. RuleDecl pass -> XRec pass (HsExpr pass)
    rd_lhs  = XRec GhcPs (HsExpr GhcPs)
    lhs
                         , rd_rhs :: forall pass. RuleDecl pass -> XRec pass (HsExpr pass)
    rd_rhs  = XRec GhcPs (HsExpr GhcPs)
    rhs })
      = do { let rdr_names_w_loc :: FreeKiTyVars
    rdr_names_w_loc = (GenLocated EpAnnCO (RuleBndr GhcPs)
     -> GenLocated SrcSpanAnnN RdrName)
    -> [GenLocated EpAnnCO (RuleBndr GhcPs)] -> FreeKiTyVars
    forall a b. (a -> b) -> [a] -> [b]
    map (RuleBndr GhcPs -> GenLocated SrcSpanAnnN RdrName
    get_var (RuleBndr GhcPs -> GenLocated SrcSpanAnnN RdrName)
    -> (GenLocated EpAnnCO (RuleBndr GhcPs) -> RuleBndr GhcPs)
    -> GenLocated EpAnnCO (RuleBndr GhcPs)
    -> GenLocated SrcSpanAnnN RdrName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated EpAnnCO (RuleBndr GhcPs) -> RuleBndr GhcPs
    forall l e. GenLocated l e -> e
    unLoc) [LRuleBndr GhcPs]
    [GenLocated EpAnnCO (RuleBndr GhcPs)]
    tmvs
           ; FreeKiTyVars -> TcRn ()
    checkDupRdrNames FreeKiTyVars
    rdr_names_w_loc
           ; FreeKiTyVars -> TcRn ()
    checkShadowedRdrNames FreeKiTyVars
    rdr_names_w_loc
           ; names <- FreeKiTyVars -> IOEnv (Env TcGblEnv TcLclEnv) [Name]
    newLocalBndrsRn FreeKiTyVars
    rdr_names_w_loc
           ; let doc = CLabelString -> HsDocContext
    RuleCtx (GenLocated EpAnnCO CLabelString -> CLabelString
    forall l e. GenLocated l e -> e
    unLoc XRec GhcPs CLabelString
    GenLocated EpAnnCO CLabelString
    rule_name)
           ; bindRuleTyVars doc tyvs $ \ Maybe [LHsTyVarBndr () GhcRn]
    tyvs' ->
             HsDocContext
    -> Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    -> [LRuleBndr GhcPs]
    -> [Name]
    -> ([LRuleBndr GhcRn] -> RnM (RuleDecl GhcRn, FreeVars))
    -> RnM (RuleDecl GhcRn, FreeVars)
    forall ty_bndrs a.
    HsDocContext
    -> Maybe ty_bndrs
    -> [LRuleBndr GhcPs]
    -> [Name]
    -> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    bindRuleTmVars HsDocContext
    doc Maybe [LHsTyVarBndr () GhcRn]
    Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    tyvs' [LRuleBndr GhcPs]
    tmvs [Name]
    names (([LRuleBndr GhcRn] -> RnM (RuleDecl GhcRn, FreeVars))
     -> RnM (RuleDecl GhcRn, FreeVars))
    -> ([LRuleBndr GhcRn] -> RnM (RuleDecl GhcRn, FreeVars))
    -> RnM (RuleDecl GhcRn, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ [LRuleBndr GhcRn]
    tmvs' ->
        do { (lhs', fv_lhs') <- XRec GhcPs (HsExpr GhcPs) -> TcM (LHsExpr GhcRn, FreeVars)
    rnLExpr XRec GhcPs (HsExpr GhcPs)
    lhs
           ; (rhs', fv_rhs') <- rnLExpr rhs
           ; checkValidRule (unLoc rule_name) names lhs' fv_lhs'
           ; return (HsRule { rd_ext  = (HsRuleRn fv_lhs' fv_rhs', st)
                            , rd_name = rule_name
                            , rd_act  = act
                            , rd_tyvs = tyvs'
                            , rd_tmvs = tmvs'
                            , rd_lhs  = lhs'
                            , rd_rhs  = rhs' }, fv_lhs' `plusFV` fv_rhs') } }
      where
        get_var :: RuleBndr GhcPs -> LocatedN RdrName
        get_var :: RuleBndr GhcPs -> GenLocated SrcSpanAnnN RdrName
    get_var (RuleBndrSig XRuleBndrSig GhcPs
    _ LIdP GhcPs
    v HsPatSigType GhcPs
    _) = LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    v
        get_var (RuleBndr XCRuleBndr GhcPs
    _ LIdP GhcPs
    v)      = LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    v

    bindRuleTmVars :: HsDocContext -> Maybe ty_bndrs
                   -> [LRuleBndr GhcPs] -> [Name]
                   -> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
                   -> RnM (a, FreeVars)
    bindRuleTmVars :: forall ty_bndrs a.
    HsDocContext
    -> Maybe ty_bndrs
    -> [LRuleBndr GhcPs]
    -> [Name]
    -> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    bindRuleTmVars HsDocContext
    doc Maybe ty_bndrs
    tyvs [LRuleBndr GhcPs]
    vars [Name]
    names [LRuleBndr GhcRn] -> RnM (a, FreeVars)
    thing_inside
      = [GenLocated EpAnnCO (RuleBndr GhcPs)]
    -> [Name]
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    go [LRuleBndr GhcPs]
    [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars [Name]
    names (([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
     -> RnM (a, FreeVars))
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars' ->
        [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
    forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
    bindLocalNamesFV [Name]
    names ([LRuleBndr GhcRn] -> RnM (a, FreeVars)
    thing_inside [LRuleBndr GhcRn]
    [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars')
      where
        go :: [GenLocated EpAnnCO (RuleBndr GhcPs)]
    -> [Name]
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    go ((L EpAnnCO
    l (RuleBndr XCRuleBndr GhcPs
    _ (L SrcSpanAnnN
    loc RdrName
    _))) : [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars) (Name
    n : [Name]
    ns) [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside
          = [GenLocated EpAnnCO (RuleBndr GhcPs)]
    -> [Name]
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    go [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars [Name]
    ns (([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
     -> RnM (a, FreeVars))
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars' ->
            [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside (EpAnnCO -> RuleBndr GhcRn -> GenLocated EpAnnCO (RuleBndr GhcRn)
    forall l e. l -> e -> GenLocated l e
    L EpAnnCO
    l (XCRuleBndr GhcRn -> LIdP GhcRn -> RuleBndr GhcRn
    forall pass. XCRuleBndr pass -> LIdP pass -> RuleBndr pass
    RuleBndr [AddEpAnn]
    XCRuleBndr GhcRn
    forall a. NoAnn a => a
    noAnn (SrcSpanAnnN -> Name -> GenLocated SrcSpanAnnN Name
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnN
    loc Name
    n)) GenLocated EpAnnCO (RuleBndr GhcRn)
    -> [GenLocated EpAnnCO (RuleBndr GhcRn)]
    -> [GenLocated EpAnnCO (RuleBndr GhcRn)]
    forall a. a -> [a] -> [a]
    : [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars')

        go ((L EpAnnCO
    l (RuleBndrSig XRuleBndrSig GhcPs
    _ (L SrcSpanAnnN
    loc RdrName
    _) HsPatSigType GhcPs
    bsig)) : [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars)
           (Name
    n : [Name]
    ns) [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside
          = HsPatSigTypeScoping
    -> HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a.
    HsPatSigTypeScoping
    -> HsDocContext
    -> HsPatSigType GhcPs
    -> (HsPatSigType GhcRn -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    rnHsPatSigType HsPatSigTypeScoping
    bind_free_tvs HsDocContext
    doc HsPatSigType GhcPs
    bsig ((HsPatSigType GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars))
    -> (HsPatSigType GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ HsPatSigType GhcRn
    bsig' ->
            [GenLocated EpAnnCO (RuleBndr GhcPs)]
    -> [Name]
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    go [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars [Name]
    ns (([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
     -> RnM (a, FreeVars))
    -> ([GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars))
    -> RnM (a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ \ [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars' ->
            [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside (EpAnnCO -> RuleBndr GhcRn -> GenLocated EpAnnCO (RuleBndr GhcRn)
    forall l e. l -> e -> GenLocated l e
    L EpAnnCO
    l (XRuleBndrSig GhcRn
    -> LIdP GhcRn -> HsPatSigType GhcRn -> RuleBndr GhcRn
    forall pass.
    XRuleBndrSig pass
    -> LIdP pass -> HsPatSigType pass -> RuleBndr pass
    RuleBndrSig [AddEpAnn]
    XRuleBndrSig GhcRn
    forall a. NoAnn a => a
    noAnn (SrcSpanAnnN -> Name -> GenLocated SrcSpanAnnN Name
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnN
    loc Name
    n) HsPatSigType GhcRn
    bsig') GenLocated EpAnnCO (RuleBndr GhcRn)
    -> [GenLocated EpAnnCO (RuleBndr GhcRn)]
    -> [GenLocated EpAnnCO (RuleBndr GhcRn)]
    forall a. a -> [a] -> [a]
    : [GenLocated EpAnnCO (RuleBndr GhcRn)]
    vars')

        go [] [] [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside = [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    thing_inside []
        go [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars [Name]
    names [GenLocated EpAnnCO (RuleBndr GhcRn)] -> RnM (a, FreeVars)
    _ = String -> SDoc -> RnM (a, FreeVars)
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "bindRuleVars" ([GenLocated EpAnnCO (RuleBndr GhcPs)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [GenLocated EpAnnCO (RuleBndr GhcPs)]
    vars SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [Name] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Name]
    names)

        bind_free_tvs :: HsPatSigTypeScoping
    bind_free_tvs = case Maybe ty_bndrs
    tyvs of Maybe ty_bndrs
    Nothing -> HsPatSigTypeScoping
    AlwaysBind
                                     Just ty_bndrs
    _  -> HsPatSigTypeScoping
    NeverBind

    bindRuleTyVars :: HsDocContext -> Maybe [LHsTyVarBndr () GhcPs]
                   -> (Maybe [LHsTyVarBndr () GhcRn]  -> RnM (b, FreeVars))
                   -> RnM (b, FreeVars)
    bindRuleTyVars :: forall b.
    HsDocContext
    -> Maybe [LHsTyVarBndr () GhcPs]
    -> (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
    -> RnM (b, FreeVars)
    bindRuleTyVars HsDocContext
    doc (Just [LHsTyVarBndr () GhcPs]
    bndrs) Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
    thing_inside
      = HsDocContext
    -> WarnUnusedForalls
    -> Maybe Any
    -> [LHsTyVarBndr () GhcPs]
    -> ([LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
    -> RnM (b, FreeVars)
    forall flag a b.
    OutputableBndrFlag flag 'Renamed =>
    HsDocContext
    -> WarnUnusedForalls
    -> Maybe a
    -> [LHsTyVarBndr flag GhcPs]
    -> ([LHsTyVarBndr flag GhcRn] -> RnM (b, FreeVars))
    -> RnM (b, FreeVars)
    bindLHsTyVarBndrs HsDocContext
    doc WarnUnusedForalls
    WarnUnusedForalls Maybe Any
    forall a. Maybe a
    Nothing [LHsTyVarBndr () GhcPs]
    bndrs (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
    Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    -> RnM (b, FreeVars)
    thing_inside (Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
     -> RnM (b, FreeVars))
    -> ([GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
        -> Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)])
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    -> RnM (b, FreeVars)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    -> Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    forall a. a -> Maybe a
    Just)
    bindRuleTyVars HsDocContext
    _ Maybe [LHsTyVarBndr () GhcPs]
    _ Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
    thing_inside = Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
    thing_inside Maybe [LHsTyVarBndr () GhcRn]
    Maybe [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    forall a. Maybe a
    Nothing

    {-
    Note [Rule LHS validity checking]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Check the shape of a rewrite rule LHS.  Currently we only allow
    LHSs of the form @(f e1 .. en)@, where @f@ is not one of the
    @forall@'d variables.

    We used restrict the form of the 'ei' to prevent you writing rules
    with LHSs with a complicated desugaring (and hence unlikely to match);
    (e.g. a case expression is not allowed: too elaborate.)

    But there are legitimate non-trivial args ei, like sections and
    lambdas.  So it seems simpler not to check at all, and that is why
    check_e is commented out.
    -}

    checkValidRule :: FastString -> [Name] -> LHsExpr GhcRn -> NameSet -> RnM ()
    checkValidRule :: CLabelString -> [Name] -> LHsExpr GhcRn -> FreeVars -> TcRn ()
    checkValidRule CLabelString
    rule_name [Name]
    ids LHsExpr GhcRn
    lhs' FreeVars
    fv_lhs'
      = do  {       -- Check for the form of the LHS
              case ([Name] -> LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
    validRuleLhs [Name]
    ids LHsExpr GhcRn
    lhs') of
                    Maybe (HsExpr GhcRn)
    Nothing  -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                    Just HsExpr GhcRn
    bad -> TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWithTc (CLabelString -> LHsExpr GhcRn -> HsExpr GhcRn -> TcRnMessage
    badRuleLhsErr CLabelString
    rule_name LHsExpr GhcRn
    lhs' HsExpr GhcRn
    bad)

                    -- Check that LHS vars are all bound
            ; let bad_vars :: [Name]
    bad_vars = [Name
    var | Name
    var <- [Name]
    ids, Bool -> Bool
    not (Name
    var Name -> FreeVars -> Bool
    `elemNameSet` FreeVars
    fv_lhs')]
            ; (Name -> TcRn ()) -> [Name] -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (TcRnMessage -> TcRn ()
    addErr (TcRnMessage -> TcRn ())
    -> (Name -> TcRnMessage) -> Name -> TcRn ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CLabelString -> Name -> TcRnMessage
    TcRnUnusedVariableInRuleDecl CLabelString
    rule_name) [Name]
    bad_vars }

    validRuleLhs :: [Name] -> LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
    -- Nothing => OK
    -- Just e  => Not ok, and e is the offending sub-expression
    validRuleLhs :: [Name] -> LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
    validRuleLhs [Name]
    foralls LHsExpr GhcRn
    lhs
      = GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    checkl LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    lhs
      where
        checkl :: GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    checkl = HsExpr GhcRn -> Maybe (HsExpr GhcRn)
    check (HsExpr GhcRn -> Maybe (HsExpr GhcRn))
    -> (GenLocated SrcSpanAnnA (HsExpr GhcRn) -> HsExpr GhcRn)
    -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
    -> Maybe (HsExpr GhcRn)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (HsExpr GhcRn) -> HsExpr GhcRn
    forall l e. GenLocated l e -> e
    unLoc

        check :: HsExpr GhcRn -> Maybe (HsExpr GhcRn)
    check (OpApp XOpApp GhcRn
    _ LHsExpr GhcRn
    e1 LHsExpr GhcRn
    op LHsExpr GhcRn
    e2)              = GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    checkl LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    op Maybe (HsExpr GhcRn)
    -> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus` GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall {p} {a}. p -> Maybe a
    checkl_e LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    e1
                                                          Maybe (HsExpr GhcRn)
    -> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus` GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall {p} {a}. p -> Maybe a
    checkl_e LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    e2
        check (HsApp XApp GhcRn
    _ LHsExpr GhcRn
    e1 LHsExpr GhcRn
    e2)                 = GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    checkl LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    e1 Maybe (HsExpr GhcRn)
    -> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus` GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    forall {p} {a}. p -> Maybe a
    checkl_e LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    e2
        check (HsAppType XAppTypeE GhcRn
    _ LHsExpr GhcRn
    e LHsWcType (NoGhcTc GhcRn)
    _)               = GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
    checkl LHsExpr GhcRn
    GenLocated SrcSpanAnnA (HsExpr GhcRn)
    e
        check (HsVar XVar GhcRn
    _ LIdP GhcRn
    lv)
          | (GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LIdP GhcRn
    GenLocated SrcSpanAnnN Name
    lv) Name -> [Name] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem` [Name]
    foralls      = Maybe (HsExpr GhcRn)
    forall a. Maybe a
    Nothing
        check HsExpr GhcRn
    other                           = HsExpr GhcRn -> Maybe (HsExpr GhcRn)
    forall a. a -> Maybe a
    Just HsExpr GhcRn
    other  -- Failure

            -- Check an argument
        checkl_e :: p -> Maybe a
    checkl_e p
    _ = Maybe a
    forall a. Maybe a
    Nothing
        -- Was (check_e e); see Note [Rule LHS validity checking]

    {-      Commented out; see Note [Rule LHS validity checking] above
        check_e (HsVar v)     = Nothing
        check_e (HsPar e)     = checkl_e e
        check_e (HsLit e)     = Nothing
        check_e (HsOverLit e) = Nothing

        check_e (OpApp e1 op _ e2)   = checkl_e e1 `mplus` checkl_e op `mplus` checkl_e e2
        check_e (HsApp e1 e2)        = checkl_e e1 `mplus` checkl_e e2
        check_e (NegApp e _)         = checkl_e e
        check_e (ExplicitList _ es)  = checkl_es es
        check_e other                = Just other   -- Fails

        checkl_es es = foldr (mplus . checkl_e) Nothing es
    -}

    badRuleLhsErr :: FastString -> LHsExpr GhcRn -> HsExpr GhcRn -> TcRnMessage
    badRuleLhsErr :: CLabelString -> LHsExpr GhcRn -> HsExpr GhcRn -> TcRnMessage
    badRuleLhsErr CLabelString
    name LHsExpr GhcRn
    lhs HsExpr GhcRn
    bad_e
      = RuleLhsErrReason
    -> CLabelString -> LHsExpr GhcRn -> HsExpr GhcRn -> TcRnMessage
    TcRnIllegalRuleLhs RuleLhsErrReason
    errReason CLabelString
    name LHsExpr GhcRn
    lhs HsExpr GhcRn
    bad_e
      where
        errReason :: RuleLhsErrReason
    errReason = case HsExpr GhcRn
    bad_e of
          HsUnboundVar XUnboundVar GhcRn
    _ RdrName
    uv ->
            RdrName -> NotInScopeError -> RuleLhsErrReason
    UnboundVariable RdrName
    uv (NotInScopeError -> RuleLhsErrReason)
    -> NotInScopeError -> RuleLhsErrReason
    forall a b. (a -> b) -> a -> b
    $ WhereLooking -> RdrName -> NotInScopeError
    notInScopeErr WhereLooking
    WL_Global RdrName
    uv
          HsExpr GhcRn
    _ -> RuleLhsErrReason
    IllegalExpression

    {- **************************************************************
             *                                                      *
          Renaming type, class, instance and role declarations
    *                                                               *
    *****************************************************************

    @rnTyDecl@ uses the `global name function' to create a new type
    declaration in which local names have been replaced by their original
    names, reporting any unknown names.

    Renaming type variables is a pain. Because they now contain uniques,
    it is necessary to pass in an association list which maps a parsed
    tyvar to its @Name@ representation.
    In some cases (type signatures of values),
    it is even necessary to go over the type first
    in order to get the set of tyvars used by it, make an assoc list,
    and then go over it again to rename the tyvars!
    However, we can also do some scoping checks at the same time.

    Note [Dependency analysis of type, class, and instance decls]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    A TyClGroup represents a strongly connected components of
    type/class/instance decls, together with the role annotations for the
    type/class declarations.  The renamer uses strongly connected
    component analysis to build these groups.  We do this for a number of
    reasons:

    * Improve kind error messages. Consider

         data T f a = MkT f a
         data S f a = MkS f (T f a)

      This has a kind error, but the error message is better if you
      check T first, (fixing its kind) and *then* S.  If you do kind
      inference together, you might get an error reported in S, which
      is jolly confusing.  See #4875

    * Increase kind polymorphism.  See GHC.Tc.TyCl
      Note [Grouping of type and class declarations]

    Why do the instance declarations participate?  At least two reasons

    * Consider (#11348)

         type family F a
         type instance F Int = Bool

         data R = MkR (F Int)

         type Foo = 'MkR 'True

      For Foo to kind-check we need to know that (F Int) ~ Bool.  But we won't
      know that unless we've looked at the type instance declaration for F
      before kind-checking Foo.

    * Another example is this (#3990).

         data family Complex a
         data instance Complex Double = CD {-# UNPACK #-} !Double
                                           {-# UNPACK #-} !Double

         data T = T {-# UNPACK #-} !(Complex Double)

      Here, to generate the right kind of unpacked implementation for T,
      we must have access to the 'data instance' declaration.

    * Things become more complicated when we introduce transitive
      dependencies through imported definitions, like in this scenario:

          A.hs
            type family Closed (t :: Type) :: Type where
              Closed t = Open t

            type family Open (t :: Type) :: Type

          B.hs
            data Q where
              Q :: Closed Bool -> Q

            type instance Open Int = Bool

            type S = 'Q 'True

      Somehow, we must ensure that the instance Open Int = Bool is checked before
      the type synonym S. While we know that S depends upon 'Q depends upon Closed,
      we have no idea that Closed depends upon Open!

      To accommodate for these situations, we ensure that an instance is checked
      before every @TyClDecl@ on which it does not depend. That's to say, instances
      are checked as early as possible in @tcTyAndClassDecls@.

    ------------------------------------
    So much for WHY.  What about HOW?  It's pretty easy:

    (1) Rename the type/class, instance, and role declarations
        individually

    (2) Do strongly-connected component analysis of the type/class decls,
        We'll make a TyClGroup for each SCC

        In this step we treat a reference to a (promoted) data constructor
        K as a dependency on its parent type.  Thus
            data T = K1 | K2
            data S = MkS (Proxy 'K1)
        Here S depends on 'K1 and hence on its parent T.

        In this step we ignore instances; see
        Note [No dependencies on data instances]

    (3) Attach roles to the appropriate SCC

    (4) Attach instances to the appropriate SCC.
        We add an instance decl to SCC when:
          all its free types/classes are bound in this SCC or earlier ones

    (5) We make an initial TyClGroup, with empty group_tyclds, for any
        (orphan) instances that affect only imported types/classes

    Steps (3) and (4) are done by the (mapAccumL mk_group) call.

    Note [No dependencies on data instances]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider this
       data family D a
       data instance D Int = D1
       data S = MkS (Proxy 'D1)

    Here the declaration of S depends on the /data instance/ declaration
    for 'D Int'.  That makes things a lot more complicated, especially
    if the data instance is an associated type of an enclosing class instance.
    (And the class instance might have several associated type instances
    with different dependency structure!)

    Ugh.  For now we simply don't allow promotion of data constructors for
    data instances.  See Note [AFamDataCon: not promoting data family
    constructors] in GHC.Tc.Utils.Env
    -}

    rnTyClDecls :: [TyClGroup GhcPs]
                -> RnM ([TyClGroup GhcRn], FreeVars)
    -- Rename the declarations and do dependency analysis on them
    rnTyClDecls :: [TyClGroup GhcPs] -> RnM ([TyClGroup GhcRn], FreeVars)
    rnTyClDecls [TyClGroup GhcPs]
    tycl_ds
      = do { -- Rename the type/class, instance, and role declarations
           ; tycls_w_fvs <- (GenLocated SrcSpanAnnA (TyClDecl GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars))
    -> [GenLocated SrcSpanAnnA (TyClDecl GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((TyClDecl GhcPs -> TcM (TyClDecl GhcRn, FreeVars))
    -> GenLocated SrcSpanAnnA (TyClDecl GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
    forall a b c ann.
    (a -> TcM (b, c))
    -> GenLocated (EpAnn ann) a -> TcM (GenLocated (EpAnn ann) b, c)
    wrapLocFstMA TyClDecl GhcPs -> TcM (TyClDecl GhcRn, FreeVars)
    rnTyClDecl) ([TyClGroup GhcPs] -> [LTyClDecl GhcPs]
    forall pass. [TyClGroup pass] -> [LTyClDecl pass]
    tyClGroupTyClDecls [TyClGroup GhcPs]
    tycl_ds)
           ; let tc_names = [Name] -> FreeVars
    mkNameSet (((GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars) -> Name)
    -> [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (TyClDecl GhcRn -> IdP GhcRn
    TyClDecl GhcRn -> Name
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> IdP (GhcPass p)
    tcdName (TyClDecl GhcRn -> Name)
    -> ((GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
        -> TyClDecl GhcRn)
    -> (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
    -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> TyClDecl GhcRn
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> TyClDecl GhcRn)
    -> ((GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
        -> GenLocated SrcSpanAnnA (TyClDecl GhcRn))
    -> (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
    -> TyClDecl GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
    -> GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    forall a b. (a, b) -> a
    fst) [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    tycls_w_fvs)
           ; traceRn "rnTyClDecls" $
               vcat [ text "tyClGroupTyClDecls:" <+> ppr tycls_w_fvs
                    , text "tc_names:" <+> ppr tc_names ]
           ; kisigs_w_fvs <- rnStandaloneKindSignatures tc_names (tyClGroupKindSigs tycl_ds)
           ; instds_w_fvs <- mapM (wrapLocFstMA rnSrcInstDecl) (tyClGroupInstDecls tycl_ds)
           ; role_annots  <- rnRoleAnnots tc_names (tyClGroupRoleDecls tycl_ds)

           -- Do SCC analysis on the type/class decls
           ; rdr_env <- getGlobalRdrEnv
           ; traceRn "rnTyClDecls SCC analysis" $
               vcat [ text "rdr_env:" <+> ppr rdr_env ]
           ; let tycl_sccs = GlobalRdrEnv
    -> KindSig_FV_Env
    -> [(LTyClDecl GhcRn, FreeVars)]
    -> [SCC (LTyClDecl GhcRn)]
    depAnalTyClDecls GlobalRdrEnv
    rdr_env KindSig_FV_Env
    kisig_fv_env [(LTyClDecl GhcRn, FreeVars)]
    [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    tycls_w_fvs
                 role_annot_env = [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
    mkRoleAnnotEnv [LRoleAnnotDecl GhcRn]
    [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn)]
    role_annots
                 (kisig_env, kisig_fv_env) = mkKindSig_fv_env kisigs_w_fvs

                 inst_ds_map = GlobalRdrEnv
    -> FreeVars -> InstDeclFreeVarsMap -> InstDeclFreeVarsMap
    mkInstDeclFreeVarsMap GlobalRdrEnv
    rdr_env FreeVars
    tc_names InstDeclFreeVarsMap
    [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    instds_w_fvs
                 (init_inst_ds, rest_inst_ds) = getInsts [] inst_ds_map

                 first_group
                   | [GenLocated SrcSpanAnnA (InstDecl GhcRn)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LInstDecl GhcRn]
    [GenLocated SrcSpanAnnA (InstDecl GhcRn)]
    init_inst_ds = []
                   | Bool
    otherwise = [TyClGroup { group_ext :: XCTyClGroup GhcRn
    group_ext    = XCTyClGroup GhcRn
    NoExtField
    noExtField
                                            , group_tyclds :: [LTyClDecl GhcRn]
    group_tyclds = []
                                            , group_kisigs :: [LStandaloneKindSig GhcRn]
    group_kisigs = []
                                            , group_roles :: [LRoleAnnotDecl GhcRn]
    group_roles  = []
                                            , group_instds :: [LInstDecl GhcRn]
    group_instds = [LInstDecl GhcRn]
    init_inst_ds }]

                 (final_inst_ds, groups)
                    = mapAccumL (mk_group role_annot_env kisig_env) rest_inst_ds tycl_sccs

                 all_fvs = ((GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
     -> FreeVars -> FreeVars)
    -> FreeVars
    -> [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    -> FreeVars
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FreeVars -> FreeVars -> FreeVars
    plusFV (FreeVars -> FreeVars -> FreeVars)
    -> ((GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
        -> FreeVars)
    -> (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)
    -> FreeVars
    -> FreeVars
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars) -> FreeVars
    forall a b. (a, b) -> b
    snd) FreeVars
    emptyFVs [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    tycls_w_fvs  FreeVars -> FreeVars -> FreeVars
    `plusFV`
                           ((GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
     -> FreeVars -> FreeVars)
    -> FreeVars
    -> [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    -> FreeVars
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FreeVars -> FreeVars -> FreeVars
    plusFV (FreeVars -> FreeVars -> FreeVars)
    -> ((GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
        -> FreeVars)
    -> (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    -> FreeVars
    -> FreeVars
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars) -> FreeVars
    forall a b. (a, b) -> b
    snd) FreeVars
    emptyFVs [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    instds_w_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV`
                           ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
     -> FreeVars -> FreeVars)
    -> FreeVars
    -> [(GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)]
    -> FreeVars
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FreeVars -> FreeVars -> FreeVars
    plusFV (FreeVars -> FreeVars -> FreeVars)
    -> ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
        -> FreeVars)
    -> (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> FreeVars
    -> FreeVars
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> FreeVars
    forall a b. (a, b) -> b
    snd) FreeVars
    emptyFVs [(GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)]
    kisigs_w_fvs

                 all_groups = [TyClGroup GhcRn]
    first_group [TyClGroup GhcRn] -> [TyClGroup GhcRn] -> [TyClGroup GhcRn]
    forall a. [a] -> [a] -> [a]
    ++ [TyClGroup GhcRn]
    groups

           ; massertPpr (null final_inst_ds)
                        (ppr instds_w_fvs
                         $$ ppr inst_ds_map
                         $$ ppr (flattenSCCs tycl_sccs)
                         $$ ppr final_inst_ds)

           ; traceRn "rnTycl dependency analysis made groups" (ppr all_groups)
           ; return (all_groups, all_fvs) }
      where
        mk_group :: RoleAnnotEnv
                 -> KindSigEnv
                 -> InstDeclFreeVarsMap
                 -> SCC (LTyClDecl GhcRn)
                 -> (InstDeclFreeVarsMap, TyClGroup GhcRn)
        mk_group :: RoleAnnotEnv
    -> KindSigEnv
    -> InstDeclFreeVarsMap
    -> SCC (LTyClDecl GhcRn)
    -> (InstDeclFreeVarsMap, TyClGroup GhcRn)
    mk_group RoleAnnotEnv
    role_env KindSigEnv
    kisig_env InstDeclFreeVarsMap
    inst_map SCC (LTyClDecl GhcRn)
    scc
          = (InstDeclFreeVarsMap
    inst_map', TyClGroup GhcRn
    group)
          where
            tycl_ds :: [GenLocated SrcSpanAnnA (TyClDecl GhcRn)]
    tycl_ds              = SCC (GenLocated SrcSpanAnnA (TyClDecl GhcRn))
    -> [GenLocated SrcSpanAnnA (TyClDecl GhcRn)]
    forall vertex. SCC vertex -> [vertex]
    flattenSCC SCC (LTyClDecl GhcRn)
    SCC (GenLocated SrcSpanAnnA (TyClDecl GhcRn))
    scc
            bndrs :: [Name]
    bndrs                = (GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> Name)
    -> [GenLocated SrcSpanAnnA (TyClDecl GhcRn)] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (TyClDecl GhcRn -> IdP GhcRn
    TyClDecl GhcRn -> Name
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> IdP (GhcPass p)
    tcdName (TyClDecl GhcRn -> Name)
    -> (GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> TyClDecl GhcRn)
    -> GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> TyClDecl GhcRn
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated SrcSpanAnnA (TyClDecl GhcRn)]
    tycl_ds
            roles :: [LRoleAnnotDecl GhcRn]
    roles                = [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]
    getRoleAnnots [Name]
    bndrs RoleAnnotEnv
    role_env
            kisigs :: [LStandaloneKindSig GhcRn]
    kisigs               = [Name] -> KindSigEnv -> [LStandaloneKindSig GhcRn]
    getKindSigs   [Name]
    bndrs KindSigEnv
    kisig_env
            ([LInstDecl GhcRn]
    inst_ds, InstDeclFreeVarsMap
    inst_map') = [Name]
    -> InstDeclFreeVarsMap -> ([LInstDecl GhcRn], InstDeclFreeVarsMap)
    getInsts      [Name]
    bndrs InstDeclFreeVarsMap
    inst_map
            group :: TyClGroup GhcRn
    group = TyClGroup { group_ext :: XCTyClGroup GhcRn
    group_ext    = XCTyClGroup GhcRn
    NoExtField
    noExtField
                              , group_tyclds :: [LTyClDecl GhcRn]
    group_tyclds = [LTyClDecl GhcRn]
    [GenLocated SrcSpanAnnA (TyClDecl GhcRn)]
    tycl_ds
                              , group_kisigs :: [LStandaloneKindSig GhcRn]
    group_kisigs = [LStandaloneKindSig GhcRn]
    kisigs
                              , group_roles :: [LRoleAnnotDecl GhcRn]
    group_roles  = [LRoleAnnotDecl GhcRn]
    roles
                              , group_instds :: [LInstDecl GhcRn]
    group_instds = [LInstDecl GhcRn]
    inst_ds }

    -- | Free variables of standalone kind signatures.
    newtype KindSig_FV_Env = KindSig_FV_Env (NameEnv FreeVars)

    lookupKindSig_FV_Env :: KindSig_FV_Env -> Name -> FreeVars
    lookupKindSig_FV_Env :: KindSig_FV_Env -> Name -> FreeVars
    lookupKindSig_FV_Env (KindSig_FV_Env NameEnv FreeVars
    e) Name
    name
      = FreeVars -> Maybe FreeVars -> FreeVars
    forall a. a -> Maybe a -> a
    fromMaybe FreeVars
    emptyFVs (NameEnv FreeVars -> Name -> Maybe FreeVars
    forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv NameEnv FreeVars
    e Name
    name)

    -- | Standalone kind signatures.
    type KindSigEnv = NameEnv (LStandaloneKindSig GhcRn)

    mkKindSig_fv_env :: [(LStandaloneKindSig GhcRn, FreeVars)] -> (KindSigEnv, KindSig_FV_Env)
    mkKindSig_fv_env :: [(LStandaloneKindSig GhcRn, FreeVars)]
    -> (KindSigEnv, KindSig_FV_Env)
    mkKindSig_fv_env [(LStandaloneKindSig GhcRn, FreeVars)]
    kisigs_w_fvs = (KindSigEnv
    NameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    kisig_env, KindSig_FV_Env
    kisig_fv_env)
      where
        kisig_env :: NameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    kisig_env = ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
     -> GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    -> NameEnv
         (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> NameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    forall elt1 elt2. (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
    mapNameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)
    forall a b. (a, b) -> a
    fst NameEnv (LStandaloneKindSig GhcRn, FreeVars)
    NameEnv
      (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    compound_env
        kisig_fv_env :: KindSig_FV_Env
    kisig_fv_env = NameEnv FreeVars -> KindSig_FV_Env
    KindSig_FV_Env (((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
     -> FreeVars)
    -> NameEnv
         (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> NameEnv FreeVars
    forall elt1 elt2. (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
    mapNameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> FreeVars
    forall a b. (a, b) -> b
    snd NameEnv (LStandaloneKindSig GhcRn, FreeVars)
    NameEnv
      (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    compound_env)
        NameEnv (LStandaloneKindSig GhcRn, FreeVars)
    compound_env :: NameEnv (LStandaloneKindSig GhcRn, FreeVars)
          = ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
     -> Name)
    -> [(GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)]
    -> NameEnv
         (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    forall a. (a -> Name) -> [a] -> NameEnv a
    mkNameEnvWith (StandaloneKindSig GhcRn -> IdP GhcRn
    StandaloneKindSig GhcRn -> Name
    forall (p :: Pass).
    StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
    standaloneKindSigName (StandaloneKindSig GhcRn -> Name)
    -> ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
        -> StandaloneKindSig GhcRn)
    -> (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)
    -> StandaloneKindSig GhcRn
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)
     -> StandaloneKindSig GhcRn)
    -> ((GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
        -> GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    -> (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> StandaloneKindSig GhcRn
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    -> GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)
    forall a b. (a, b) -> a
    fst) [(LStandaloneKindSig GhcRn, FreeVars)]
    [(GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)]
    kisigs_w_fvs

    getKindSigs :: [Name] -> KindSigEnv -> [LStandaloneKindSig GhcRn]
    getKindSigs :: [Name] -> KindSigEnv -> [LStandaloneKindSig GhcRn]
    getKindSigs [Name]
    bndrs KindSigEnv
    kisig_env = (Name -> Maybe (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)))
    -> [Name] -> [GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn)]
    forall a b. (a -> Maybe b) -> [a] -> [b]
    mapMaybe (NameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    -> Name -> Maybe (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv KindSigEnv
    NameEnv (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn))
    kisig_env) [Name]
    bndrs

    rnStandaloneKindSignatures
      :: NameSet  -- names of types and classes in the current TyClGroup
      -> [LStandaloneKindSig GhcPs]
      -> RnM [(LStandaloneKindSig GhcRn, FreeVars)]
    rnStandaloneKindSignatures :: FreeVars
    -> [LStandaloneKindSig GhcPs]
    -> RnM [(LStandaloneKindSig GhcRn, FreeVars)]
    rnStandaloneKindSignatures FreeVars
    tc_names [LStandaloneKindSig GhcPs]
    kisigs
      = do { let ([GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)]
    no_dups, [NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))]
    dup_kisigs) = (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs) -> RdrName)
    -> [GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)]
    -> ([GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)],
        [NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))])
    forall b a. Ord b => (a -> b) -> [a] -> ([a], [NonEmpty a])
    removeDupsOn GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs) -> RdrName
    GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs) -> IdGhcP 'Parsed
    forall {l} {p :: Pass}.
    GenLocated l (StandaloneKindSig (GhcPass p)) -> IdGhcP p
    get_name [LStandaloneKindSig GhcPs]
    [GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)]
    kisigs
                 get_name :: GenLocated l (StandaloneKindSig (GhcPass p)) -> IdGhcP p
    get_name = StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
    StandaloneKindSig (GhcPass p) -> IdGhcP p
    forall (p :: Pass).
    StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
    standaloneKindSigName (StandaloneKindSig (GhcPass p) -> IdGhcP p)
    -> (GenLocated l (StandaloneKindSig (GhcPass p))
        -> StandaloneKindSig (GhcPass p))
    -> GenLocated l (StandaloneKindSig (GhcPass p))
    -> IdGhcP p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated l (StandaloneKindSig (GhcPass p))
    -> StandaloneKindSig (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc
           ; (NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))
     -> TcRn ())
    -> [NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))]
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ NonEmpty (LStandaloneKindSig GhcPs) -> TcRn ()
    NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))
    -> TcRn ()
    dupKindSig_Err [NonEmpty (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs))]
    dup_kisigs
           ; (GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars))
    -> [GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [(GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((StandaloneKindSig GhcPs
     -> TcM (StandaloneKindSig GhcRn, FreeVars))
    -> GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated SrcSpanAnnA (StandaloneKindSig GhcRn), FreeVars)
    forall a b c ann.
    (a -> TcM (b, c))
    -> GenLocated (EpAnn ann) a -> TcM (GenLocated (EpAnn ann) b, c)
    wrapLocFstMA (FreeVars
    -> StandaloneKindSig GhcPs
    -> TcM (StandaloneKindSig GhcRn, FreeVars)
    rnStandaloneKindSignature FreeVars
    tc_names)) [GenLocated SrcSpanAnnA (StandaloneKindSig GhcPs)]
    no_dups
           }

    rnStandaloneKindSignature
      :: NameSet  -- names of types and classes in the current TyClGroup
      -> StandaloneKindSig GhcPs
      -> RnM (StandaloneKindSig GhcRn, FreeVars)
    rnStandaloneKindSignature :: FreeVars
    -> StandaloneKindSig GhcPs
    -> TcM (StandaloneKindSig GhcRn, FreeVars)
    rnStandaloneKindSignature FreeVars
    tc_names (StandaloneKindSig XStandaloneKindSig GhcPs
    _ LIdP GhcPs
    v LHsSigType GhcPs
    ki)
      = do  { standalone_ki_sig_ok <- Extension -> TcRn Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.StandaloneKindSignatures
            ; unless standalone_ki_sig_ok $ addErr TcRnUnexpectedStandaloneKindSig
            ; new_v <- lookupSigCtxtOccRn (TopSigCtxt tc_names) (text "standalone kind signature") v
            ; let doc = SDoc -> HsDocContext
    StandaloneKindSigCtx (GenLocated SrcSpanAnnN RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    v)
            ; (new_ki, fvs) <- rnHsSigType doc KindLevel ki
            ; return (StandaloneKindSig noExtField new_v new_ki, fvs)
            }

    depAnalTyClDecls :: GlobalRdrEnv
                     -> KindSig_FV_Env
                     -> [(LTyClDecl GhcRn, FreeVars)]
                     -> [SCC (LTyClDecl GhcRn)]
    -- See Note [Dependency analysis of type, class, and instance decls]
    depAnalTyClDecls :: GlobalRdrEnv
    -> KindSig_FV_Env
    -> [(LTyClDecl GhcRn, FreeVars)]
    -> [SCC (LTyClDecl GhcRn)]
    depAnalTyClDecls GlobalRdrEnv
    rdr_env KindSig_FV_Env
    kisig_fv_env [(LTyClDecl GhcRn, FreeVars)]
    ds_w_fvs
      = [Node Name (GenLocated SrcSpanAnnA (TyClDecl GhcRn))]
    -> [SCC (GenLocated SrcSpanAnnA (TyClDecl GhcRn))]
    forall key payload.
    Uniquable key =>
    [Node key payload] -> [SCC payload]
    stronglyConnCompFromEdgedVerticesUniq [Node Name (LTyClDecl GhcRn)]
    [Node Name (GenLocated SrcSpanAnnA (TyClDecl GhcRn))]
    edges
      where
        edges :: [ Node Name (LTyClDecl GhcRn) ]
        edges :: [Node Name (LTyClDecl GhcRn)]
    edges = [ GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    -> Name
    -> [Name]
    -> Node Name (GenLocated SrcSpanAnnA (TyClDecl GhcRn))
    forall key payload. payload -> key -> [key] -> Node key payload
    DigraphNode GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    d IdP GhcRn
    Name
    name ((Name -> Name) -> [Name] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (GlobalRdrEnv -> Name -> Name
    getParent GlobalRdrEnv
    rdr_env) (FreeVars -> [Name]
    forall elt. UniqSet elt -> [elt]
    nonDetEltsUniqSet FreeVars
    deps))
                | (GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    d, FreeVars
    fvs) <- [(LTyClDecl GhcRn, FreeVars)]
    [(GenLocated SrcSpanAnnA (TyClDecl GhcRn), FreeVars)]
    ds_w_fvs,
                  let { name :: IdP GhcRn
    name = TyClDecl GhcRn -> IdP GhcRn
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> IdP (GhcPass p)
    tcdName (GenLocated SrcSpanAnnA (TyClDecl GhcRn) -> TyClDecl GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnA (TyClDecl GhcRn)
    d)
                      ; kisig_fvs :: FreeVars
    kisig_fvs = KindSig_FV_Env -> Name -> FreeVars
    lookupKindSig_FV_Env KindSig_FV_Env
    kisig_fv_env IdP GhcRn
    Name
    name
                      ; deps :: FreeVars
    deps = FreeVars
    fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    kisig_fvs
                      }
                ]
                -- It's OK to use nonDetEltsUFM here as
                -- stronglyConnCompFromEdgedVertices is still deterministic
                -- even if the edges are in nondeterministic order as explained
                -- in Note [Deterministic SCC] in GHC.Data.Graph.Directed.

    toParents :: GlobalRdrEnv -> NameSet -> NameSet
    toParents :: GlobalRdrEnv -> FreeVars -> FreeVars
    toParents GlobalRdrEnv
    rdr_env FreeVars
    ns
      = (Name -> FreeVars -> FreeVars) -> FreeVars -> FreeVars -> FreeVars
    forall elt a. (elt -> a -> a) -> a -> UniqSet elt -> a
    nonDetStrictFoldUniqSet Name -> FreeVars -> FreeVars
    add FreeVars
    emptyNameSet FreeVars
    ns
      -- It's OK to use a non-deterministic fold because we immediately forget the
      -- ordering by creating a set
      where
        add :: Name -> FreeVars -> FreeVars
    add Name
    n FreeVars
    s = FreeVars -> Name -> FreeVars
    extendNameSet FreeVars
    s (GlobalRdrEnv -> Name -> Name
    getParent GlobalRdrEnv
    rdr_env Name
    n)

    getParent :: GlobalRdrEnv -> Name -> Name
    getParent :: GlobalRdrEnv -> Name -> Name
    getParent GlobalRdrEnv
    rdr_env Name
    n
      = case GlobalRdrEnv -> Name -> Maybe (GlobalRdrEltX GREInfo)
    forall info.
    Outputable info =>
    GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
    lookupGRE_Name GlobalRdrEnv
    rdr_env Name
    n of
          Just GlobalRdrEltX GREInfo
    gre -> case GlobalRdrEltX GREInfo -> Parent
    forall info. GlobalRdrEltX info -> Parent
    greParent GlobalRdrEltX GREInfo
    gre of
                        ParentIs  { par_is :: Parent -> Name
    par_is = Name
    p } -> Name
    p
                        Parent
    _                        -> Name
    n
          Maybe (GlobalRdrEltX GREInfo)
    Nothing -> Name
    n

    {- ******************************************************
    *                                                       *
           Role annotations
    *                                                       *
    ****************************************************** -}

    -- | Renames role annotations, returning them as the values in a NameEnv
    -- and checks for duplicate role annotations.
    -- It is quite convenient to do both of these in the same place.
    -- See also Note [Role annotations in the renamer]
    rnRoleAnnots :: NameSet
                 -> [LRoleAnnotDecl GhcPs]
                 -> RnM [LRoleAnnotDecl GhcRn]
    rnRoleAnnots :: FreeVars -> [LRoleAnnotDecl GhcPs] -> RnM [LRoleAnnotDecl GhcRn]
    rnRoleAnnots FreeVars
    tc_names [LRoleAnnotDecl GhcPs]
    role_annots
      = do {  -- Check for duplicates *before* renaming, to avoid
              -- lumping together all the unboundNames
             let ([GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)]
    no_dups, [NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs))]
    dup_annots) = (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs) -> RdrName)
    -> [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)]
    -> ([GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)],
        [NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs))])
    forall b a. Ord b => (a -> b) -> [a] -> ([a], [NonEmpty a])
    removeDupsOn GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs) -> RdrName
    GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs) -> IdGhcP 'Parsed
    forall {l} {p :: Pass}.
    GenLocated l (RoleAnnotDecl (GhcPass p)) -> IdGhcP p
    get_name [LRoleAnnotDecl GhcPs]
    [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)]
    role_annots
                 get_name :: GenLocated l (RoleAnnotDecl (GhcPass p)) -> IdGhcP p
    get_name = RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
    RoleAnnotDecl (GhcPass p) -> IdGhcP p
    forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
    roleAnnotDeclName (RoleAnnotDecl (GhcPass p) -> IdGhcP p)
    -> (GenLocated l (RoleAnnotDecl (GhcPass p))
        -> RoleAnnotDecl (GhcPass p))
    -> GenLocated l (RoleAnnotDecl (GhcPass p))
    -> IdGhcP p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated l (RoleAnnotDecl (GhcPass p))
    -> RoleAnnotDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc
           ; (NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs))
     -> TcRn ())
    -> [NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs))]
    -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ NonEmpty (LRoleAnnotDecl GhcPs) -> TcRn ()
    NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)) -> TcRn ()
    dupRoleAnnotErr [NonEmpty (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs))]
    dup_annots
           ; (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn)))
    -> [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn))
    -> GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn))
    forall a b ann.
    (a -> TcM b)
    -> GenLocated (EpAnn ann) a -> TcRn (GenLocated (EpAnn ann) b)
    wrapLocMA RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn)
    rn_role_annot1) [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcPs)]
    no_dups }
      where
        rn_role_annot1 :: RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn)
    rn_role_annot1 (RoleAnnotDecl XCRoleAnnotDecl GhcPs
    _ LIdP GhcPs
    tycon [XRec GhcPs (Maybe Role)]
    roles)
          = do {  -- the name is an *occurrence*, but look it up only in the
                  -- decls defined in this group (see #10263)
                 tycon' <- HsSigCtxt
    -> SDoc
    -> GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    forall ann.
    HsSigCtxt
    -> SDoc
    -> GenLocated (EpAnn ann) RdrName
    -> RnM (GenLocated (EpAnn ann) Name)
    lookupSigCtxtOccRn (FreeVars -> HsSigCtxt
    RoleAnnotCtxt FreeVars
    tc_names)
                                              (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "role annotation")
                                              LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
               ; return $ RoleAnnotDecl noExtField tycon' roles }

    dupRoleAnnotErr :: NonEmpty (LRoleAnnotDecl GhcPs) -> RnM ()
    dupRoleAnnotErr :: NonEmpty (LRoleAnnotDecl GhcPs) -> TcRn ()
    dupRoleAnnotErr list :: NonEmpty (LRoleAnnotDecl GhcPs)
    list@(L SrcSpanAnnA
    loc RoleAnnotDecl GhcPs
    _ :| [LRoleAnnotDecl GhcPs]
    _)
      = SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt (SrcSpanAnnA -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnA
    loc) (NonEmpty (LRoleAnnotDecl GhcPs) -> TcRnMessage
    TcRnDuplicateRoleAnnot NonEmpty (LRoleAnnotDecl GhcPs)
    list)

    dupKindSig_Err :: NonEmpty (LStandaloneKindSig GhcPs) -> RnM ()
    dupKindSig_Err :: NonEmpty (LStandaloneKindSig GhcPs) -> TcRn ()
    dupKindSig_Err list :: NonEmpty (LStandaloneKindSig GhcPs)
    list@(L SrcSpanAnnA
    loc StandaloneKindSig GhcPs
    _ :| [LStandaloneKindSig GhcPs]
    _)
      = SrcSpan -> TcRnMessage -> TcRn ()
    addErrAt (SrcSpanAnnA -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnA
    loc) (NonEmpty (LStandaloneKindSig GhcPs) -> TcRnMessage
    TcRnDuplicateKindSig NonEmpty (LStandaloneKindSig GhcPs)
    list)

    {- Note [Role annotations in the renamer]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We must ensure that a type's role annotation is put in the same group as the
    proper type declaration. This is because role annotations are needed during
    type-checking when creating the type's TyCon. So, rnRoleAnnots builds a
    NameEnv (LRoleAnnotDecl Name) that maps a name to a role annotation for that
    type, if any. Then, this map can be used to add the role annotations to the
    groups after dependency analysis.

    This process checks for duplicate role annotations, where we must be careful
    to do the check *before* renaming to avoid calling all unbound names duplicates
    of one another.

    The renaming process, as usual, might identify and report errors for unbound
    names. This is done by using lookupSigCtxtOccRn in rnRoleAnnots (using
    lookupGlobalOccRn led to #8485).
    -}

    {- ******************************************************
    *                                                       *
           Dependency info for instances
    *                                                       *
    ****************************************************** -}

    ----------------------------------------------------------
    -- | 'InstDeclFreeVarsMap is an association of an
    --   @InstDecl@ with @FreeVars@. The @FreeVars@ are
    --   the tycon names that are both
    --     a) free in the instance declaration
    --     b) bound by this group of type/class/instance decls
    type InstDeclFreeVarsMap = [(LInstDecl GhcRn, FreeVars)]

    -- | Construct an @InstDeclFreeVarsMap@ by eliminating any @Name@s from the
    --   @FreeVars@ which are *not* the binders of a @TyClDecl@.
    mkInstDeclFreeVarsMap :: GlobalRdrEnv
                          -> NameSet
                          -> [(LInstDecl GhcRn, FreeVars)]
                          -> InstDeclFreeVarsMap
    mkInstDeclFreeVarsMap :: GlobalRdrEnv
    -> FreeVars -> InstDeclFreeVarsMap -> InstDeclFreeVarsMap
    mkInstDeclFreeVarsMap GlobalRdrEnv
    rdr_env FreeVars
    tycl_bndrs InstDeclFreeVarsMap
    inst_ds_fvs
      = [ (LInstDecl GhcRn
    GenLocated SrcSpanAnnA (InstDecl GhcRn)
    inst_decl, GlobalRdrEnv -> FreeVars -> FreeVars
    toParents GlobalRdrEnv
    rdr_env FreeVars
    fvs FreeVars -> FreeVars -> FreeVars
    `intersectFVs` FreeVars
    tycl_bndrs)
        | (GenLocated SrcSpanAnnA (InstDecl GhcRn)
    inst_decl, FreeVars
    fvs) <- InstDeclFreeVarsMap
    [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    inst_ds_fvs ]

    -- | Get the @LInstDecl@s which have empty @FreeVars@ sets, and the
    --   @InstDeclFreeVarsMap@ with these entries removed.
    -- We call (getInsts tcs instd_map) when we've completed the declarations
    -- for 'tcs'.  The call returns (inst_decls, instd_map'), where
    --   inst_decls are the instance declarations all of
    --              whose free vars are now defined
    --   instd_map' is the inst-decl map with 'tcs' removed from
    --               the free-var set
    getInsts :: [Name] -> InstDeclFreeVarsMap
             -> ([LInstDecl GhcRn], InstDeclFreeVarsMap)
    getInsts :: [Name]
    -> InstDeclFreeVarsMap -> ([LInstDecl GhcRn], InstDeclFreeVarsMap)
    getInsts [Name]
    bndrs InstDeclFreeVarsMap
    inst_decl_map
      = ((GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
     -> Either
          (GenLocated SrcSpanAnnA (InstDecl GhcRn))
          (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars))
    -> [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    -> ([GenLocated SrcSpanAnnA (InstDecl GhcRn)],
        [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)])
    forall a b c. (a -> Either b c) -> [a] -> ([b], [c])
    partitionWith (LInstDecl GhcRn, FreeVars)
    -> Either (LInstDecl GhcRn) (LInstDecl GhcRn, FreeVars)
    (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    -> Either
         (GenLocated SrcSpanAnnA (InstDecl GhcRn))
         (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    pick_me InstDeclFreeVarsMap
    [(GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)]
    inst_decl_map
      where
        pick_me :: (LInstDecl GhcRn, FreeVars)
                -> Either (LInstDecl GhcRn) (LInstDecl GhcRn, FreeVars)
        pick_me :: (LInstDecl GhcRn, FreeVars)
    -> Either (LInstDecl GhcRn) (LInstDecl GhcRn, FreeVars)
    pick_me (LInstDecl GhcRn
    decl, FreeVars
    fvs)
          | FreeVars -> Bool
    isEmptyNameSet FreeVars
    depleted_fvs = GenLocated SrcSpanAnnA (InstDecl GhcRn)
    -> Either
         (GenLocated SrcSpanAnnA (InstDecl GhcRn))
         (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    forall a b. a -> Either a b
    Left LInstDecl GhcRn
    GenLocated SrcSpanAnnA (InstDecl GhcRn)
    decl
          | Bool
    otherwise                   = (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    -> Either
         (GenLocated SrcSpanAnnA (InstDecl GhcRn))
         (GenLocated SrcSpanAnnA (InstDecl GhcRn), FreeVars)
    forall a b. b -> Either a b
    Right (LInstDecl GhcRn
    GenLocated SrcSpanAnnA (InstDecl GhcRn)
    decl, FreeVars
    depleted_fvs)
          where
            depleted_fvs :: FreeVars
    depleted_fvs = [Name] -> FreeVars -> FreeVars
    delFVs [Name]
    bndrs FreeVars
    fvs

    {- ******************************************************
    *                                                       *
             Renaming a type or class declaration
    *                                                       *
    ****************************************************** -}

    rnTyClDecl :: TyClDecl GhcPs
               -> RnM (TyClDecl GhcRn, FreeVars)

    -- All flavours of top-level type family declarations ("type family", "newtype
    -- family", and "data family")
    rnTyClDecl :: TyClDecl GhcPs -> TcM (TyClDecl GhcRn, FreeVars)
    rnTyClDecl (FamDecl { tcdFam :: forall pass. TyClDecl pass -> FamilyDecl pass
    tcdFam = FamilyDecl GhcPs
    fam })
      = do { (fam', fvs) <- Maybe (Name, [Name])
    -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
    rnFamDecl Maybe (Name, [Name])
    forall a. Maybe a
    Nothing FamilyDecl GhcPs
    fam
           ; return (FamDecl noExtField fam', fvs) }

    rnTyClDecl (SynDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP GhcPs
    tycon, tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars GhcPs
    tyvars,
                          tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity, tcdRhs :: forall pass. TyClDecl pass -> LHsType pass
    tcdRhs = LHsType GhcPs
    rhs })
      = do { tycon' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
           ; let kvs = LHsType GhcPs -> FreeKiTyVars
    extractHsTyRdrTyVarsKindVars LHsType GhcPs
    rhs
                 doc = GenLocated SrcSpanAnnN RdrName -> HsDocContext
    TySynCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
           ; traceRn "rntycl-ty" (ppr tycon <+> ppr kvs)
           ; bindHsQTyVars doc Nothing kvs tyvars $ \ LHsQTyVars GhcRn
    tyvars' FreeKiTyVars
    free_rhs_kvs ->
        do { (GenLocated SrcSpanAnnN RdrName -> TcRn ())
    -> FreeKiTyVars -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ GenLocated SrcSpanAnnN RdrName -> TcRn ()
    warn_implicit_kvs (FreeKiTyVars -> FreeKiTyVars
    forall a l. Eq a => [GenLocated l a] -> [GenLocated l a]
    nubL FreeKiTyVars
    free_rhs_kvs)
           ; (rhs', fvs) <- HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnTySyn HsDocContext
    doc LHsType GhcPs
    rhs
           ; return (SynDecl { tcdLName = tycon', tcdTyVars = tyvars'
                             , tcdFixity = fixity
                             , tcdRhs = rhs', tcdSExt = fvs }, fvs) } }
      where
        warn_implicit_kvs :: LocatedN RdrName -> RnM ()
        warn_implicit_kvs :: GenLocated SrcSpanAnnN RdrName -> TcRn ()
    warn_implicit_kvs GenLocated SrcSpanAnnN RdrName
    kv =
          SrcSpan -> TcRnMessage -> TcRn ()
    addDiagnosticAt (GenLocated SrcSpanAnnN RdrName -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA GenLocated SrcSpanAnnN RdrName
    kv) (GenLocated SrcSpanAnnN RdrName -> TcRnMessage
    TcRnImplicitRhsQuantification GenLocated SrcSpanAnnN RdrName
    kv)

    -- "data", "newtype" declarations
    rnTyClDecl (DataDecl
        { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP GhcPs
    tycon, tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars GhcPs
    tyvars,
          tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity,
          tcdDataDefn :: forall pass. TyClDecl pass -> HsDataDefn pass
    tcdDataDefn = defn :: HsDataDefn GhcPs
    defn@HsDataDefn{ dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl GhcPs)
    cons, dd_kindSig :: forall pass. HsDataDefn pass -> Maybe (LHsKind pass)
    dd_kindSig = Maybe (LHsType GhcPs)
    kind_sig} })
      = do { tycon' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
           ; let kvs = HsDataDefn GhcPs -> FreeKiTyVars
    extractDataDefnKindVars HsDataDefn GhcPs
    defn
                 doc = GenLocated SrcSpanAnnN RdrName -> HsDocContext
    TyDataCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
                 new_or_data = DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs)) -> NewOrData
    forall a. DataDefnCons a -> NewOrData
    dataDefnConsNewOrData DataDefnCons (LConDecl GhcPs)
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs))
    cons
           ; traceRn "rntycl-data" (ppr tycon <+> ppr kvs)
           ; bindHsQTyVars doc Nothing kvs tyvars $ \ LHsQTyVars GhcRn
    tyvars' FreeKiTyVars
    free_rhs_kvs ->
        do { (defn', fvs) <- HsDocContext
    -> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars)
    rnDataDefn HsDocContext
    doc HsDataDefn GhcPs
    defn
           ; cusk <- data_decl_has_cusk tyvars' new_or_data (null free_rhs_kvs) kind_sig
           ; let rn_info = DataDeclRn { tcdDataCusk :: Bool
    tcdDataCusk = Bool
    cusk
                                      , tcdFVs :: FreeVars
    tcdFVs      = FreeVars
    fvs }
           ; traceRn "rndata" (ppr tycon <+> ppr cusk <+> ppr free_rhs_kvs)
           ; return (DataDecl { tcdLName    = tycon'
                              , tcdTyVars   = tyvars'
                              , tcdFixity   = fixity
                              , tcdDataDefn = defn'
                              , tcdDExt     = rn_info }, fvs) } }

    rnTyClDecl (ClassDecl { tcdCtxt :: forall pass. TyClDecl pass -> Maybe (LHsContext pass)
    tcdCtxt = Maybe (LHsContext GhcPs)
    context, tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP GhcPs
    lcls,
                            tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars GhcPs
    tyvars, tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity,
                            tcdFDs :: forall pass. TyClDecl pass -> [LHsFunDep pass]
    tcdFDs = [LHsFunDep GhcPs]
    fds, tcdSigs :: forall pass. TyClDecl pass -> [LSig pass]
    tcdSigs = [LSig GhcPs]
    sigs,
                            tcdMeths :: forall pass. TyClDecl pass -> LHsBinds pass
    tcdMeths = LHsBinds GhcPs
    mbinds, tcdATs :: forall pass. TyClDecl pass -> [LFamilyDecl pass]
    tcdATs = [LFamilyDecl GhcPs]
    ats, tcdATDefs :: forall pass. TyClDecl pass -> [LTyFamDefltDecl pass]
    tcdATDefs = [LTyFamInstDecl GhcPs]
    at_defs,
                            tcdDocs :: forall pass. TyClDecl pass -> [LDocDecl pass]
    tcdDocs = [LDocDecl GhcPs]
    docs})
      = do  { lcls' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    lcls
            ; let cls' = GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnN Name
    lcls'
                  kvs = []  -- No scoped kind vars except those in
                            -- kind signatures on the tyvars

            -- Tyvars scope over superclass context and method signatures
            ; ((tyvars', context', fds', ats'), stuff_fvs)
                <- bindHsQTyVars cls_doc Nothing kvs tyvars $ \ LHsQTyVars GhcRn
    tyvars' FreeKiTyVars
    _ -> do
                      -- Checks for distinct tyvars
                 { (context', cxt_fvs) <- HsDocContext
    -> Maybe (LHsContext GhcPs)
    -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMaybeContext HsDocContext
    cls_doc Maybe (LHsContext GhcPs)
    context
                 ; fds'  <- rnFds fds
                             -- The fundeps have no free variables
                 ; (ats', fv_ats) <- rnATDecls cls' (hsAllLTyVarNames tyvars') ats
                 ; let fvs = FreeVars
    cxt_fvs     FreeVars -> FreeVars -> FreeVars
    `plusFV`
                             FreeVars
    fv_ats
                 ; return ((tyvars', context', fds', ats'), fvs) }

            ; (at_defs', fv_at_defs) <- rnList (rnTyFamDefltDecl cls') at_defs

            -- No need to check for duplicate associated type decls
            -- since that is done by GHC.Rename.Names.extendGlobalRdrEnvRn

            -- Check the signatures
            -- First process the class op sigs (op_sigs), then the fixity sigs (non_op_sigs).
            ; let sig_rdr_names_w_locs =
                    [GenLocated SrcSpanAnnN RdrName
    op | L SrcSpanAnnA
    _ (ClassOpSig XClassOpSig GhcPs
    _ Bool
    False [LIdP GhcPs]
    ops LHsSigType GhcPs
    _) <- [LSig GhcPs]
    [GenLocated SrcSpanAnnA (Sig GhcPs)]
    sigs
                        , GenLocated SrcSpanAnnN RdrName
    op <- [LIdP GhcPs]
    FreeKiTyVars
    ops]
            ; checkDupRdrNames sig_rdr_names_w_locs
                    -- Typechecker is responsible for checking that we only
                    -- give default-method bindings for things in this class.
                    -- The renamer *could* check this for class decls, but can't
                    -- for instance decls.

            -- The newLocals call is tiresome: given a generic class decl
            --      class C a where
            --        op :: a -> a
            --        op {| x+y |} (Inl a) = ...
            --        op {| x+y |} (Inr b) = ...
            --        op {| a*b |} (a*b)   = ...
            -- we want to name both "x" tyvars with the same unique, so that they are
            -- easy to group together in the typechecker.
            ; (mbinds', sigs', meth_fvs)
                <- rnMethodBinds True cls' (hsAllLTyVarNames tyvars') mbinds sigs
                    -- No need to check for duplicate method signatures
                    -- since that is done by GHC.Rename.Names.extendGlobalRdrEnvRn
                    -- and the methods are already in scope

            ; let all_fvs = FreeVars
    meth_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    stuff_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fv_at_defs
            ; docs' <- traverse rnLDocDecl docs
            ; return (ClassDecl { tcdCtxt = context', tcdLName = lcls',
                                  tcdTyVars = tyvars', tcdFixity = fixity,
                                  tcdFDs = fds', tcdSigs = sigs',
                                  tcdMeths = mbinds', tcdATs = ats', tcdATDefs = at_defs',
                                  tcdDocs = docs', tcdCExt = all_fvs },
                      all_fvs ) }
      where
        cls_doc :: HsDocContext
    cls_doc  = GenLocated SrcSpanAnnN RdrName -> HsDocContext
    ClassDeclCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    lcls

    -- Does the data type declaration include a CUSK?
    data_decl_has_cusk :: LHsQTyVars (GhcPass p) -> NewOrData -> Bool -> Maybe (LHsKind (GhcPass p')) -> RnM Bool
    data_decl_has_cusk :: forall (p :: Pass) (p' :: Pass).
    LHsQTyVars (GhcPass p)
    -> NewOrData -> Bool -> Maybe (LHsKind (GhcPass p')) -> TcRn Bool
    data_decl_has_cusk LHsQTyVars (GhcPass p)
    tyvars NewOrData
    new_or_data Bool
    no_rhs_kvs Maybe (LHsKind (GhcPass p'))
    kind_sig = do
      { -- See Note [Unlifted Newtypes and CUSKs], and for a broader
        -- picture, see Note [Implementation of UnliftedNewtypes].
      ; unlifted_newtypes <- Extension -> TcRn Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.UnliftedNewtypes
      ; let non_cusk_newtype
              | NewOrData
    NewType <- NewOrData
    new_or_data =
                  Bool
    unlifted_newtypes Bool -> Bool -> Bool
    && Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p'))) -> Bool
    forall a. Maybe a -> Bool
    isNothing Maybe (LHsKind (GhcPass p'))
    Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p')))
    kind_sig
              | Bool
    otherwise = Bool
    False
        -- See Note [CUSKs: complete user-supplied kind signatures] in GHC.Hs.Decls
      ; return $ hsTvbAllKinded tyvars && no_rhs_kvs && not non_cusk_newtype
      }

    {- Note [Unlifted Newtypes and CUSKs]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When unlifted newtypes are enabled, a newtype must have a kind signature
    in order to be considered have a CUSK. This is because the flow of
    kind inference works differently. Consider:

      newtype Foo = FooC Int

    When UnliftedNewtypes is disabled, we decide that Foo has kind
    `TYPE 'LiftedRep` without looking inside the data constructor. So, we
    can say that Foo has a CUSK. However, when UnliftedNewtypes is enabled,
    we fill in the kind of Foo as a metavar that gets solved by unification
    with the kind of the field inside FooC (that is, Int, whose kind is
    `TYPE 'LiftedRep`). But since we have to look inside the data constructors
    to figure out the kind signature of Foo, it does not have a CUSK.

    See Note [Implementation of UnliftedNewtypes] for where this fits in to
    the broader picture of UnliftedNewtypes.
    -}

    -- "type" and "type instance" declarations
    rnTySyn :: HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnTySyn :: HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnTySyn HsDocContext
    doc LHsType GhcPs
    rhs = HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnLHsType HsDocContext
    doc LHsType GhcPs
    rhs

    rnDataDefn :: HsDocContext -> HsDataDefn GhcPs
               -> RnM (HsDataDefn GhcRn, FreeVars)
    rnDataDefn :: HsDocContext
    -> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars)
    rnDataDefn HsDocContext
    doc (HsDataDefn { dd_cType :: forall pass. HsDataDefn pass -> Maybe (XRec pass CType)
    dd_cType = Maybe (XRec GhcPs CType)
    cType, dd_ctxt :: forall pass. HsDataDefn pass -> Maybe (LHsContext pass)
    dd_ctxt = Maybe (LHsContext GhcPs)
    context, dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl GhcPs)
    condecls
                               , dd_kindSig :: forall pass. HsDataDefn pass -> Maybe (LHsKind pass)
    dd_kindSig = Maybe (LHsType GhcPs)
    m_sig, dd_derivs :: forall pass. HsDataDefn pass -> HsDeriving pass
    dd_derivs = HsDeriving GhcPs
    derivs })
      = do  { -- DatatypeContexts (i.e., stupid contexts) can't be combined with
              -- GADT syntax. See Note [The stupid context] in GHC.Core.DataCon.
              Bool -> TcRnMessage -> TcRn ()
    checkTc (Bool
    h98_style Bool -> Bool -> Bool
    || [GenLocated SrcSpanAnnA (HsType GhcPs)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null (Maybe (LHsContext GhcPs) -> [LHsType GhcPs]
    forall (p :: Pass).
    Maybe (LHsContext (GhcPass p)) -> HsContext (GhcPass p)
    fromMaybeContext Maybe (LHsContext GhcPs)
    context))
                      (HsDocContext -> TcRnMessage
    TcRnStupidThetaInGadt HsDocContext
    doc)

            -- Check restrictions on "type data" declarations.
            -- See Note [Type data declarations].
            ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs)) -> Bool
    forall a. DataDefnCons a -> Bool
    isTypeDataDefnCons DataDefnCons (LConDecl GhcPs)
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs))
    condecls) TcRn ()
    check_type_data

            ; (m_sig', sig_fvs) <- case Maybe (LHsType GhcPs)
    m_sig of
                 Just LHsType GhcPs
    sig -> (GenLocated SrcSpanAnnA (HsType GhcRn)
     -> Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)))
    -> (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
    -> (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars)
    forall b c d. (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first GenLocated SrcSpanAnnA (HsType GhcRn)
    -> Maybe (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall a. a -> Maybe a
    Just ((GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
     -> (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars))
    -> RnM (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnLHsKind HsDocContext
    doc LHsType GhcPs
    sig
                 Maybe (LHsType GhcPs)
    Nothing  -> (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall a. Maybe a
    Nothing, FreeVars
    emptyFVs)
            ; (context', fvs1) <- rnMaybeContext doc context
            ; (derivs',  fvs3) <- rn_derivs derivs

            -- For the constructor declarations, drop the LocalRdrEnv
            -- in the GADT case, where the type variables in the declaration
            -- do not scope over the constructor signatures
            -- data T a where { T1 :: forall b. b-> b }
            ; let { zap_lcl_env | Bool
    h98_style = \ RnM
      (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcRn)), FreeVars)
    thing -> RnM
      (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcRn)), FreeVars)
    thing
                                | Bool
    otherwise = LocalRdrEnv
    -> RnM
         (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcRn)), FreeVars)
    -> RnM
         (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcRn)), FreeVars)
    forall a. LocalRdrEnv -> RnM a -> RnM a
    setLocalRdrEnv LocalRdrEnv
    emptyLocalRdrEnv }
            ; (condecls', con_fvs) <- zap_lcl_env $ rnConDecls condecls
               -- No need to check for duplicate constructor decls
               -- since that is done by GHC.Rename.Names.extendGlobalRdrEnvRn

            ; let all_fvs = FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs3 FreeVars -> FreeVars -> FreeVars
    `plusFV`
                            FreeVars
    con_fvs FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    sig_fvs
            ; return ( HsDataDefn { dd_ext = noExtField, dd_cType = cType
                                  , dd_ctxt = context', dd_kindSig = m_sig'
                                  , dd_cons = condecls'
                                  , dd_derivs = derivs' }
                     , all_fvs )
            }
      where
        h98_style :: Bool
    h98_style = Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs)) -> Bool
    forall (f :: * -> *) l pass.
    Foldable f =>
    f (GenLocated l (ConDecl pass)) -> Bool
    anyLConIsGadt DataDefnCons (LConDecl GhcPs)
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs))
    condecls  -- Note [Stupid theta]

        rn_derivs :: [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         ([GenLocated EpAnnCO (HsDerivingClause GhcRn)], FreeVars)
    rn_derivs [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
    ds
          = do { deriv_strats_ok <- Extension -> TcRn Bool
    forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
    xoptM Extension
    LangExt.DerivingStrategies
               ; failIfTc (lengthExceeds ds 1 && not deriv_strats_ok)
                   TcRnIllegalMultipleDerivClauses
               ; (ds', fvs) <- mapFvRn (rnLHsDerivingClause doc) ds
               ; return (ds', fvs) }

        -- Given a "type data" declaration, check that the TypeData extension
        -- is enabled and check restrictions (R1), (R2), (R3) and (R5)
        -- on the declaration.  See Note [Type data declarations].
        check_type_data :: TcRn ()
    check_type_data
          = do { Extension -> TcRn () -> TcRn ()
    forall gbl lcl. Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    unlessXOptM Extension
    LangExt.TypeData (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith TcRnMessage
    TcRnIllegalTypeData
               ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless ([GenLocated SrcSpanAnnA (HsType GhcPs)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null (Maybe (LHsContext GhcPs) -> [LHsType GhcPs]
    forall (p :: Pass).
    Maybe (LHsContext (GhcPass p)) -> HsContext (GhcPass p)
    fromMaybeContext Maybe (LHsContext GhcPs)
    context)) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                   TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TypeDataForbids -> TcRnMessage
    TcRnTypeDataForbids TypeDataForbids
    TypeDataForbidsDatatypeContexts
               ; (GenLocated SrcSpanAnnA (ConDecl GhcPs) -> TcRn ())
    -> DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs)) -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ((ConDecl GhcPs -> TcRn ())
    -> GenLocated SrcSpanAnnA (ConDecl GhcPs) -> TcRn ()
    forall t a b. HasLoc t => (a -> TcM b) -> GenLocated t a -> TcM b
    addLocM ConDecl GhcPs -> TcRn ()
    check_type_data_condecl) DataDefnCons (LConDecl GhcPs)
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs))
    condecls
               ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless ([GenLocated EpAnnCO (HsDerivingClause GhcPs)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null HsDeriving GhcPs
    [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
    derivs) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                   TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TypeDataForbids -> TcRnMessage
    TcRnTypeDataForbids TypeDataForbids
    TypeDataForbidsDerivingClauses
               }

        -- Check restrictions (R2) and (R3) on a "type data" constructor.
        -- See Note [Type data declarations].
        check_type_data_condecl :: ConDecl GhcPs -> RnM ()
        check_type_data_condecl :: ConDecl GhcPs -> TcRn ()
    check_type_data_condecl ConDecl GhcPs
    condecl
          = do {
               ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (ConDecl GhcPs -> Bool
    forall {pass} {l}.
    (XRec pass [XRec pass (ConDeclField pass)]
     ~ GenLocated l [XRec pass (ConDeclField pass)]) =>
    ConDecl pass -> Bool
    has_labelled_fields ConDecl GhcPs
    condecl) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                   TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TypeDataForbids -> TcRnMessage
    TcRnTypeDataForbids TypeDataForbids
    TypeDataForbidsLabelledFields
               ; Bool -> TcRn () -> TcRn ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (ConDecl GhcPs -> Bool
    forall {p :: Pass}. ConDecl (GhcPass p) -> Bool
    has_strictness_flags ConDecl GhcPs
    condecl) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
                   TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TypeDataForbids -> TcRnMessage
    TcRnTypeDataForbids TypeDataForbids
    TypeDataForbidsStrictnessAnnotations
               }

        has_labelled_fields :: ConDecl pass -> Bool
    has_labelled_fields (ConDeclGADT { con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
    con_g_args = RecConGADT XRecConGADT pass
    _ XRec pass [XRec pass (ConDeclField pass)]
    _ }) = Bool
    True
        has_labelled_fields (ConDeclH98 { con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = RecCon XRec pass [XRec pass (ConDeclField pass)]
    rec })
          = Bool -> Bool
    not ([XRec pass (ConDeclField pass)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null (GenLocated l [XRec pass (ConDeclField pass)]
    -> [XRec pass (ConDeclField pass)]
    forall l e. GenLocated l e -> e
    unLoc XRec pass [XRec pass (ConDeclField pass)]
    GenLocated l [XRec pass (ConDeclField pass)]
    rec))
        has_labelled_fields ConDecl pass
    _ = Bool
    False

        has_strictness_flags :: ConDecl (GhcPass p) -> Bool
    has_strictness_flags ConDecl (GhcPass p)
    condecl
          = (HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
     -> Bool)
    -> [HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (HsSrcBang -> Bool
    is_strict (HsSrcBang -> Bool)
    -> (HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
        -> HsSrcBang)
    -> HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . LHsType (GhcPass p) -> HsSrcBang
    GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> HsSrcBang
    forall (p :: Pass). LHsType (GhcPass p) -> HsSrcBang
    getBangStrictness (GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> HsSrcBang)
    -> (HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
        -> GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> HsSrcBang
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> GenLocated SrcSpanAnnA (HsType (GhcPass p))
    forall pass a. HsScaled pass a -> a
    hsScaledThing) (ConDecl (GhcPass p) -> [HsScaled (GhcPass p) (LHsType (GhcPass p))]
    forall {pass}.
    ConDecl pass -> [HsScaled pass (XRec pass (BangType pass))]
    con_args ConDecl (GhcPass p)
    condecl)

        is_strict :: HsSrcBang -> Bool
    is_strict (HsSrcBang SourceText
    _ SrcUnpackedness
    _ SrcStrictness
    s) = SrcStrictness -> Bool
    isSrcStrict SrcStrictness
    s

        con_args :: ConDecl pass -> [HsScaled pass (XRec pass (BangType pass))]
    con_args (ConDeclGADT { con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
    con_g_args = PrefixConGADT XPrefixConGADT pass
    _ [HsScaled pass (XRec pass (BangType pass))]
    args }) = [HsScaled pass (XRec pass (BangType pass))]
    args
        con_args (ConDeclH98 { con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = PrefixCon [Void]
    _ [HsScaled pass (XRec pass (BangType pass))]
    args }) = [HsScaled pass (XRec pass (BangType pass))]
    args
        con_args (ConDeclH98 { con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = InfixCon HsScaled pass (XRec pass (BangType pass))
    arg1 HsScaled pass (XRec pass (BangType pass))
    arg2 }) = [HsScaled pass (XRec pass (BangType pass))
    arg1, HsScaled pass (XRec pass (BangType pass))
    arg2]
        con_args ConDecl pass
    _ = []

    {-
    Note [Type data declarations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    With the TypeData extension (GHC proposal #106), one can write `type data`
    declarations, like

        type data Nat = Zero | Succ Nat

    or equivalently in GADT style:

        type data Nat where
            Zero :: Nat
            Succ :: Nat -> Nat

    This defines the constructors `Zero` and `Succ` in the TcCls namespace
    (type constructors and classes) instead of the Data namespace (data
    constructors).  This contrasts with the DataKinds extension, which
    allows constructors defined in the Data namespace to be promoted to the
    TcCls namespace at the point of use in a type.

    Type data declarations have the syntax of `data` declarations (but not
    `newtype` declarations), either ordinary algebraic data types or GADTs,
    preceded by `type`, with the following restrictions:

    (R0) 'data' decls only, not 'newtype' decls.  This is checked by
         the parser.

    (R1) There are no data type contexts (even with the DatatypeContexts
         extension).

    (R2) There are no labelled fields.  Perhaps these could be supported
         using type families, but they are omitted for now.

    (R3) There are no strictness flags, because they don't make sense at
         the type level.

    (R4) The types of the constructors contain no constraints.

    (R5) There are no deriving clauses.

    The data constructors of a `type data` declaration obey the following
    Core invariant:

    (I1) The data constructors of a `type data` declaration may be mentioned in
         /types/, but never in /terms/ or the /pattern of a case alternative/.

    Wrinkles:

    (W0) Wrappers.  The data constructor of a `type data` declaration has a worker
         (like every data constructor) but does /not/ have a wrapper.  Wrappers
         only make sense for value-level data constructors. Indeed, the worker Id
         is never used (invariant (I1)), so it barely makes sense to talk about
         the worker. A `type data` constructor only shows up in types, where it
         appears as a TyCon, specifically a PromotedDataCon -- no Id in sight.

         See `wrapped_reqd` in GHC.Types.Id.Make.mkDataConRep` for the place where
         this check is implemented.

         This specifically includes `type data` declarations implemented as GADTs,
         such as this example from #22948:

            type data T a where
              A :: T Int
              B :: T a

         If `T` were an ordinary `data` declaration, then `A` would have a wrapper
         to account for the GADT-like equality in its return type. Because `T` is
         declared as a `type data` declaration, however, the wrapper is omitted.

    (W1) To prevent users from conjuring up `type data` values at the term level,
         we disallow using the tagToEnum# function on a type headed by a `type
         data` type. For instance, GHC will reject this code:

           type data Letter = A | B | C

           f :: Letter
           f = tagToEnum# 0#

         See `GHC.Tc.Gen.App.checkTagToEnum`, specifically `check_enumeration`.

    (W2) Although `type data` data constructors do not exist at the value level,
         it is still possible to match on a value whose type is headed by a `type data`
         type constructor, such as this example from #22964:

           type data T a where
             A :: T Int
             B :: T a

           f :: T a -> ()
           f x = case x of {}

         And yet we must guarantee invariant (I1). This has three consequences:

         (W2a) During checking the coverage of `f`'s pattern matches, we treat `T`
               as if it were an empty data type so that GHC does not warn the user
               to match against `A` or `B`. (Otherwise, you end up with the bug
               reported in #22964.)  See GHC.HsToCore.Pmc.Solver.vanillaCompleteMatchTC.

         (W2b) In `GHC.Core.Utils.refineDataAlt`, do /not/ fill in the DEFAULT case
               with the data constructor, else (I1) is violated. See GHC.Core.Utils
               Note [Refine DEFAULT case alternatives] Exception 2

         (W2c) In `GHC.Core.Opt.ConstantFold.caseRules`, we do not want to transform
                  case dataToTagLarge# x of t -> blah
               into
                  case x of { A -> ...; B -> .. }
               because again that conjures up the type-level-only data constructors
               `A` and `B` in a pattern, violating (I1) (#23023).
               So we check for "type data" TyCons before applying this
               transformation.  (In practice, this doesn't matter because
               we also refuse to solve DataToTag instances at types
               corresponding to type data declarations.  See rule C1 from
               Note [DataToTag overview] in GHC.Tc.Instance.Class.)

    The main parts of the implementation are:

    * The parser recognizes `type data` (but not `type newtype`); this ensures (R0).

    * During the initial construction of the AST,
      GHC.Parser.PostProcess.checkNewOrData sets the `Bool` argument of the
      `DataTypeCons` inside a `HsDataDefn` to mark a `type data` declaration.
      It also puts the the constructor names (`Zero` and `Succ` in our
      example) in the TcCls namespace.

    * GHC.Rename.Module.rnDataDefn calls `check_type_data` on these
      declarations, which checks that the TypeData extension is enabled and
      checks restrictions (R1), (R2), (R3) and (R5).  They could equally
      well be checked in the typechecker, but we err on the side of catching
      imposters early.

    * GHC.Tc.TyCl.checkValidDataCon checks restriction (R4) on these declarations.

    * When beginning to type check a mutually recursive group of declarations,
      the `type data` constructors (`Zero` and `Succ` in our example) are
      added to the type-checker environment as `APromotionErr TyConPE` by
      GHC.Tc.TyCl.mkPromotionErrorEnv, so they cannot be used within the
      recursive group.  This mirrors the DataKinds behaviour described
      at Note [Recursion and promoting data constructors] in GHC.Tc.TyCl.
      For example, this is rejected:

        type data T f = K (f (K Int)) -- illegal: tycon K is recursively defined

    * The `type data` data type, such as `Nat` in our example, is represented
      by a `TyCon` that is an `AlgTyCon`, but its `AlgTyConRhs` has the
      `is_type_data` field set.

    * The constructors of the data type, `Zero` and `Succ` in our example,
      are each represented by a `DataCon` as usual.  That `DataCon`'s
      `dcPromotedField` is a `TyCon` (for `Zero`, say) that you can use
      in a type.

    * After a `type data` declaration has been type-checked, the
      type-checker environment entry (a `TyThing`) for each constructor
      (`Zero` and `Succ` in our example) is
      - just an `ATyCon` for the promoted type constructor,
      - not the bundle (`ADataCon` for the data con, `AnId` for the work id,
        wrap id) required for a normal data constructor
      See GHC.Types.TyThing.implicitTyConThings.

    * GHC.Core.TyCon.isDataKindsPromotedDataCon ignores promoted constructors
      from `type data`, which do not use the distinguishing quote mark added
      to constructors promoted by DataKinds.

    * GHC.Core.TyCon.isDataTyCon ignores types coming from a `type data`
      declaration (by checking the `is_type_data` field), so that these do
      not contribute executable code such as constructor wrappers.

    * The `is_type_data` field is copied into a Boolean argument
      of the `IfDataTyCon` constructor of `IfaceConDecls` by
      GHC.Iface.Make.tyConToIfaceDecl.

    * The Template Haskell `Dec` type has an constructor `TypeDataD` for
      `type data` declarations.  When these are converted back to Hs types
      in a splice, the constructors are placed in the TcCls namespace.

    -}

    warnNoDerivStrat :: Maybe (LDerivStrategy GhcRn)
                     -> SrcSpan
                     -> RnM ()
    warnNoDerivStrat :: Maybe (LDerivStrategy GhcRn) -> SrcSpan -> TcRn ()
    warnNoDerivStrat Maybe (LDerivStrategy GhcRn)
    mds SrcSpan
    loc
      = do { dyn_flags <- IOEnv (Env TcGblEnv TcLclEnv) DynFlags
    forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
           ; case mds of
               Maybe (LDerivStrategy GhcRn)
    Nothing ->
                 SrcSpan -> TcRnMessage -> TcRn ()
    addDiagnosticAt SrcSpan
    loc (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ Bool -> TcRnMessage
    TcRnNoDerivStratSpecified
                  (Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.DerivingStrategies DynFlags
    dyn_flags)
               Maybe (LDerivStrategy GhcRn)
    _ -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
           }

    rnLHsDerivingClause :: HsDocContext -> LHsDerivingClause GhcPs
                        -> RnM (LHsDerivingClause GhcRn, FreeVars)
    rnLHsDerivingClause :: HsDocContext
    -> LHsDerivingClause GhcPs
    -> RnM (LHsDerivingClause GhcRn, FreeVars)
    rnLHsDerivingClause HsDocContext
    doc
                    (L EpAnnCO
    loc (HsDerivingClause
                                  { deriv_clause_ext :: forall pass. HsDerivingClause pass -> XCHsDerivingClause pass
    deriv_clause_ext = XCHsDerivingClause GhcPs
    noExtField
                                  , deriv_clause_strategy :: forall pass. HsDerivingClause pass -> Maybe (LDerivStrategy pass)
    deriv_clause_strategy = Maybe (LDerivStrategy GhcPs)
    dcs
                                  , deriv_clause_tys :: forall pass. HsDerivingClause pass -> LDerivClauseTys pass
    deriv_clause_tys = LDerivClauseTys GhcPs
    dct }))
      = do { (dcs', dct', fvs)
               <- HsDocContext
    -> Maybe (LDerivStrategy GhcPs)
    -> RnM (LDerivClauseTys GhcRn, FreeVars)
    -> RnM
         (Maybe (LDerivStrategy GhcRn), LDerivClauseTys GhcRn, FreeVars)
    forall a.
    HsDocContext
    -> Maybe (LDerivStrategy GhcPs)
    -> RnM (a, FreeVars)
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    rnLDerivStrategy HsDocContext
    doc Maybe (LDerivStrategy GhcPs)
    dcs (RnM (LDerivClauseTys GhcRn, FreeVars)
     -> RnM
          (Maybe (LDerivStrategy GhcRn), LDerivClauseTys GhcRn, FreeVars))
    -> RnM (LDerivClauseTys GhcRn, FreeVars)
    -> RnM
         (Maybe (LDerivStrategy GhcRn), LDerivClauseTys GhcRn, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ LDerivClauseTys GhcPs -> RnM (LDerivClauseTys GhcRn, FreeVars)
    rn_deriv_clause_tys LDerivClauseTys GhcPs
    dct
           ; warnNoDerivStrat dcs' (locA loc)
           ; pure ( L loc (HsDerivingClause { deriv_clause_ext = noExtField
                                            , deriv_clause_strategy = dcs'
                                            , deriv_clause_tys = dct' })
                  , fvs ) }
      where
        rn_deriv_clause_tys :: LDerivClauseTys GhcPs
                            -> RnM (LDerivClauseTys GhcRn, FreeVars)
        rn_deriv_clause_tys :: LDerivClauseTys GhcPs -> RnM (LDerivClauseTys GhcRn, FreeVars)
    rn_deriv_clause_tys (L SrcSpanAnnC
    l DerivClauseTys GhcPs
    dct) = case DerivClauseTys GhcPs
    dct of
          DctSingle XDctSingle GhcPs
    x LHsSigType GhcPs
    ty -> do
            (ty', fvs) <- LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
    rn_clause_pred LHsSigType GhcPs
    ty
            pure (L l (DctSingle x ty'), fvs)
          DctMulti XDctMulti GhcPs
    x [LHsSigType GhcPs]
    tys -> do
            (tys', fvs) <- (GenLocated SrcSpanAnnA (HsSigType GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated SrcSpanAnnA (HsSigType GhcRn), FreeVars))
    -> [GenLocated SrcSpanAnnA (HsSigType GhcPs)]
    -> RnM ([GenLocated SrcSpanAnnA (HsSigType GhcRn)], FreeVars)
    forall (f :: * -> *) a b.
    Traversable f =>
    (a -> RnM (b, FreeVars)) -> f a -> RnM (f b, FreeVars)
    mapFvRn LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
    GenLocated SrcSpanAnnA (HsSigType GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (GenLocated SrcSpanAnnA (HsSigType GhcRn), FreeVars)
    rn_clause_pred [LHsSigType GhcPs]
    [GenLocated SrcSpanAnnA (HsSigType GhcPs)]
    tys
            pure (L l (DctMulti x tys'), fvs)

        rn_clause_pred :: LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
        rn_clause_pred :: LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
    rn_clause_pred LHsSigType GhcPs
    pred_ty = do
          HsDocContext -> LHsSigType GhcPs -> TcRn ()
    checkInferredVars HsDocContext
    doc LHsSigType GhcPs
    pred_ty
          ret@(pred_ty', _) <- HsDocContext
    -> TypeOrKind
    -> LHsSigType GhcPs
    -> RnM (LHsSigType GhcRn, FreeVars)
    rnHsSigType HsDocContext
    doc TypeOrKind
    TypeLevel LHsSigType GhcPs
    pred_ty
          -- Check if there are any nested `forall`s, which are illegal in a
          -- `deriving` clause.
          -- See Note [No nested foralls or contexts in instance types]
          -- (Wrinkle: Derived instances) in GHC.Hs.Type.
          addNoNestedForallsContextsErr doc NFC_DerivedClassType
            (getLHsInstDeclHead pred_ty')
          pure ret

    rnLDerivStrategy :: forall a.
                        HsDocContext
                     -> Maybe (LDerivStrategy GhcPs)
                     -> RnM (a, FreeVars)
                     -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    rnLDerivStrategy :: forall a.
    HsDocContext
    -> Maybe (LDerivStrategy GhcPs)
    -> RnM (a, FreeVars)
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    rnLDerivStrategy HsDocContext
    doc Maybe (LDerivStrategy GhcPs)
    mds RnM (a, FreeVars)
    thing_inside
      = case Maybe (LDerivStrategy GhcPs)
    mds of
          Maybe (LDerivStrategy GhcPs)
    Nothing -> Maybe (GenLocated EpAnnCO (DerivStrategy GhcRn))
    -> RnM
         (Maybe (GenLocated EpAnnCO (DerivStrategy GhcRn)), a, FreeVars)
    forall ds. ds -> RnM (ds, a, FreeVars)
    boring_case Maybe (GenLocated EpAnnCO (DerivStrategy GhcRn))
    forall a. Maybe a
    Nothing
          Just (L EpAnnCO
    loc DerivStrategy GhcPs
    ds) ->
            EpAnnCO
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA EpAnnCO
    loc (RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
     -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars))
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    -> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
    forall a b. (a -> b) -> a -> b
    $ do
              (ds', thing, fvs) <- DerivStrategy GhcPs -> RnM (DerivStrategy GhcRn, a, FreeVars)
    rn_deriv_strat DerivStrategy GhcPs
    ds
              pure (Just (L loc ds'), thing, fvs)
      where
        rn_deriv_strat :: DerivStrategy GhcPs
                       -> RnM (DerivStrategy GhcRn, a, FreeVars)
        rn_deriv_strat :: DerivStrategy GhcPs -> RnM (DerivStrategy GhcRn, a, FreeVars)
    rn_deriv_strat DerivStrategy GhcPs
    ds = do
          let extNeeded :: LangExt.Extension
              extNeeded :: Extension
    extNeeded
                | ViaStrategy{} <- DerivStrategy GhcPs
    ds
                = Extension
    LangExt.DerivingVia
                | Bool
    otherwise
                = Extension
    LangExt.DerivingStrategies

          Extension -> TcRn () -> TcRn ()
    forall gbl lcl. Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    unlessXOptM Extension
    extNeeded (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $
            TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ DerivStrategy GhcPs -> TcRnMessage
    TcRnIllegalDerivStrategy DerivStrategy GhcPs
    ds

          case DerivStrategy GhcPs
    ds of
            StockStrategy    XStockStrategy GhcPs
    _ -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
    forall ds. ds -> RnM (ds, a, FreeVars)
    boring_case (XStockStrategy GhcRn -> DerivStrategy GhcRn
    forall pass. XStockStrategy pass -> DerivStrategy pass
    StockStrategy XStockStrategy GhcRn
    NoExtField
    noExtField)
            AnyclassStrategy XAnyClassStrategy GhcPs
    _ -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
    forall ds. ds -> RnM (ds, a, FreeVars)
    boring_case (XAnyClassStrategy GhcRn -> DerivStrategy GhcRn
    forall pass. XAnyClassStrategy pass -> DerivStrategy pass
    AnyclassStrategy XAnyClassStrategy GhcRn
    NoExtField
    noExtField)
            NewtypeStrategy  XNewtypeStrategy GhcPs
    _ -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
    forall ds. ds -> RnM (ds, a, FreeVars)
    boring_case (XNewtypeStrategy GhcRn -> DerivStrategy GhcRn
    forall pass. XNewtypeStrategy pass -> DerivStrategy pass
    NewtypeStrategy XNewtypeStrategy GhcRn
    NoExtField
    noExtField)
            ViaStrategy (XViaStrategyPs [AddEpAnn]
    _ LHsSigType GhcPs
    via_ty) ->
              do HsDocContext -> LHsSigType GhcPs -> TcRn ()
    checkInferredVars HsDocContext
    doc LHsSigType GhcPs
    via_ty
                 (via_ty', fvs1) <- HsDocContext
    -> TypeOrKind
    -> LHsSigType GhcPs
    -> RnM (LHsSigType GhcRn, FreeVars)
    rnHsSigType HsDocContext
    doc TypeOrKind
    TypeLevel LHsSigType GhcPs
    via_ty
                 let HsSig { sig_bndrs = via_outer_bndrs
                           , sig_body  = via_body } = unLoc via_ty'
                     via_tvs = HsOuterTyVarBndrs Specificity GhcRn -> [Name]
    forall flag. HsOuterTyVarBndrs flag GhcRn -> [Name]
    hsOuterTyVarNames HsOuterTyVarBndrs Specificity GhcRn
    via_outer_bndrs
                 -- Check if there are any nested `forall`s, which are illegal in a
                 -- `via` type.
                 -- See Note [No nested foralls or contexts in instance types]
                 -- (Wrinkle: Derived instances) in GHC.Hs.Type.
                 addNoNestedForallsContextsErr doc
                   NFC_ViaType via_body
                 (thing, fvs2) <- bindLocalNamesFV via_tvs thing_inside
                 pure (ViaStrategy via_ty', thing, fvs1 `plusFV` fvs2)

        boring_case :: ds -> RnM (ds, a, FreeVars)
        boring_case :: forall ds. ds -> RnM (ds, a, FreeVars)
    boring_case ds
    ds = do
          (thing, fvs) <- RnM (a, FreeVars)
    thing_inside
          pure (ds, thing, fvs)

    rnFamDecl :: Maybe (Name, [Name])
                            -- Just (cls, cls_tvs) => this FamilyDecl is nested
                            --             inside an *class decl* for cls
                            --             used for associated types
              -> FamilyDecl GhcPs
              -> RnM (FamilyDecl GhcRn, FreeVars)
    rnFamDecl :: Maybe (Name, [Name])
    -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
    rnFamDecl Maybe (Name, [Name])
    mb_cls (FamilyDecl { fdLName :: forall pass. FamilyDecl pass -> LIdP pass
    fdLName = LIdP GhcPs
    tycon, fdTyVars :: forall pass. FamilyDecl pass -> LHsQTyVars pass
    fdTyVars = LHsQTyVars GhcPs
    tyvars
                                 , fdTopLevel :: forall pass. FamilyDecl pass -> TopLevelFlag
    fdTopLevel = TopLevelFlag
    toplevel
                                 , fdFixity :: forall pass. FamilyDecl pass -> LexicalFixity
    fdFixity = LexicalFixity
    fixity
                                 , fdInfo :: forall pass. FamilyDecl pass -> FamilyInfo pass
    fdInfo = FamilyInfo GhcPs
    info, fdResultSig :: forall pass. FamilyDecl pass -> LFamilyResultSig pass
    fdResultSig = LFamilyResultSig GhcPs
    res_sig
                                 , fdInjectivityAnn :: forall pass. FamilyDecl pass -> Maybe (LInjectivityAnn pass)
    fdInjectivityAnn = Maybe (LInjectivityAnn GhcPs)
    injectivity })
      = do { tycon' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
           ; ((tyvars', res_sig', injectivity'), fv1) <-
                bindHsQTyVars doc mb_cls kvs tyvars $ \ LHsQTyVars GhcRn
    tyvars' FreeKiTyVars
    _ ->
                do { let rn_sig :: FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
    rn_sig = HsDocContext
    -> FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
    rnFamResultSig HsDocContext
    doc
                   ; (res_sig', fv_kind) <- (FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars))
    -> GenLocated EpAnnCO (FamilyResultSig GhcPs)
    -> TcM (GenLocated EpAnnCO (FamilyResultSig GhcRn), FreeVars)
    forall a b c ann.
    (a -> TcM (b, c))
    -> GenLocated (EpAnn ann) a -> TcM (GenLocated (EpAnn ann) b, c)
    wrapLocFstMA FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
    rn_sig LFamilyResultSig GhcPs
    GenLocated EpAnnCO (FamilyResultSig GhcPs)
    res_sig
                   ; injectivity' <- traverse (rnInjectivityAnn tyvars' res_sig')
                                              injectivity
                   ; return ( (tyvars', res_sig', injectivity') , fv_kind ) }
           ; (info', fv2) <- rn_info info
           ; return (FamilyDecl { fdExt = noAnn
                                , fdLName = tycon', fdTyVars = tyvars'
                                , fdTopLevel = toplevel
                                , fdFixity = fixity
                                , fdInfo = info', fdResultSig = res_sig'
                                , fdInjectivityAnn = injectivity' }
                    , fv1 `plusFV` fv2) }
      where
         doc :: HsDocContext
    doc = GenLocated SrcSpanAnnN RdrName -> HsDocContext
    TyFamilyCtx LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    tycon
         kvs :: FreeKiTyVars
    kvs = LFamilyResultSig GhcPs -> FreeKiTyVars
    extractRdrKindSigVars LFamilyResultSig GhcPs
    res_sig

         ----------------------
         rn_info :: FamilyInfo GhcPs -> RnM (FamilyInfo GhcRn, FreeVars)
         rn_info :: FamilyInfo GhcPs -> RnM (FamilyInfo GhcRn, FreeVars)
    rn_info (ClosedTypeFamily (Just [LTyFamInstEqn GhcPs]
    eqns))
           = do { (eqns', fvs)
                    <- (FamEqn GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (FamEqn GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars))
    -> [LocatedA
          (FamEqn GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs)))]
    -> RnM
         ([LocatedA (FamEqn GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)))],
          FreeVars)
    forall a b.
    (a -> RnM (b, FreeVars))
    -> [LocatedA a] -> RnM ([LocatedA b], FreeVars)
    rnList (AssocTyFamInfo
    -> TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars)
    rnTyFamInstEqn (ClosedTyFamInfo -> AssocTyFamInfo
    NonAssocTyFamEqn ClosedTyFamInfo
    ClosedTyFam)) [LTyFamInstEqn GhcPs]
    [LocatedA (FamEqn GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs)))]
    eqns
                                              -- no class context
                ; return (ClosedTypeFamily (Just eqns'), fvs) }
         rn_info (ClosedTypeFamily Maybe [LTyFamInstEqn GhcPs]
    Nothing)
           = (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe [LTyFamInstEqn GhcRn] -> FamilyInfo GhcRn
    forall pass. Maybe [LTyFamInstEqn pass] -> FamilyInfo pass
    ClosedTypeFamily Maybe [LTyFamInstEqn GhcRn]
    Maybe
      [LocatedA (FamEqn GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)))]
    forall a. Maybe a
    Nothing, FreeVars
    emptyFVs)
         rn_info FamilyInfo GhcPs
    OpenTypeFamily = (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (FamilyInfo GhcRn
    forall pass. FamilyInfo pass
    OpenTypeFamily, FreeVars
    emptyFVs)
         rn_info FamilyInfo GhcPs
    DataFamily     = (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (FamilyInfo GhcRn
    forall pass. FamilyInfo pass
    DataFamily, FreeVars
    emptyFVs)

    rnFamResultSig :: HsDocContext
                   -> FamilyResultSig GhcPs
                   -> RnM (FamilyResultSig GhcRn, FreeVars)
    rnFamResultSig :: HsDocContext
    -> FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
    rnFamResultSig HsDocContext
    _ (NoSig XNoSig GhcPs
    _)
       = (FamilyResultSig GhcRn, FreeVars)
    -> RnM (FamilyResultSig GhcRn, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XNoSig GhcRn -> FamilyResultSig GhcRn
    forall pass. XNoSig pass -> FamilyResultSig pass
    NoSig XNoSig GhcRn
    NoExtField
    noExtField, FreeVars
    emptyFVs)
    rnFamResultSig HsDocContext
    doc (KindSig XCKindSig GhcPs
    _ LHsType GhcPs
    kind)
       = do { (rndKind, ftvs) <- HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
    rnLHsKind HsDocContext
    doc LHsType GhcPs
    kind
            ;  return (KindSig noExtField rndKind, ftvs) }
    rnFamResultSig HsDocContext
    doc (TyVarSig XTyVarSig GhcPs
    _ LHsTyVarBndr () GhcPs
    tvbndr)
       = do { -- `TyVarSig` tells us that user named the result of a type family by
              -- writing `= tyvar` or `= (tyvar :: kind)`. In such case we want to
              -- be sure that the supplied result name is not identical to an
              -- already in-scope type variable from an enclosing class.
              --
              --  Example of disallowed declaration:
              --         class C a b where
              --            type F b = a | a -> b
              rdr_env <- RnM LocalRdrEnv
    getLocalRdrEnv
           ;  let resName = LHsTyVarBndr () GhcPs -> IdP GhcPs
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
    hsLTyVarName LHsTyVarBndr () GhcPs
    tvbndr
           ;  when (resName `elemLocalRdrEnv` rdr_env) $
              addErrAt (getLocA tvbndr) $
                TcRnShadowedTyVarNameInFamResult resName

           ; bindLHsTyVarBndr doc Nothing -- This might be a lie, but it's used for
                                          -- scoping checks that are irrelevant here
                              tvbndr $ \ LHsTyVarBndr () GhcRn
    tvbndr' ->
             (FamilyResultSig GhcRn, FreeVars)
    -> RnM (FamilyResultSig GhcRn, FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XTyVarSig GhcRn -> LHsTyVarBndr () GhcRn -> FamilyResultSig GhcRn
    forall pass.
    XTyVarSig pass -> LHsTyVarBndr () pass -> FamilyResultSig pass
    TyVarSig XTyVarSig GhcRn
    NoExtField
    noExtField LHsTyVarBndr () GhcRn
    tvbndr', Name -> FreeVars
    unitFV (LHsTyVarBndr () GhcRn -> IdP GhcRn
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
    hsLTyVarName LHsTyVarBndr () GhcRn
    tvbndr')) }

    -- Note [Renaming injectivity annotation]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- During renaming of injectivity annotation we have to make several checks to
    -- make sure that it is well-formed.  At the moment injectivity annotation
    -- consists of a single injectivity condition, so the terms "injectivity
    -- annotation" and "injectivity condition" might be used interchangeably.  See
    -- Note [Injectivity annotation] for a detailed discussion of currently allowed
    -- injectivity annotations.
    --
    -- Checking LHS is simple because the only type variable allowed on the LHS of
    -- injectivity condition is the variable naming the result in type family head.
    -- Example of disallowed annotation:
    --
    --     type family Foo a b = r | b -> a
    --
    -- Verifying RHS of injectivity consists of checking that:
    --
    --  1. only variables defined in type family head appear on the RHS (kind
    --     variables are also allowed).  Example of disallowed annotation:
    --
    --        type family Foo a = r | r -> b
    --
    --  2. for associated types the result variable does not shadow any of type
    --     class variables. Example of disallowed annotation:
    --
    --        class Foo a b where
    --           type F a = b | b -> a
    --
    -- Breaking any of these assumptions results in an error.

    -- | Rename injectivity annotation. Note that injectivity annotation is just the
    -- part after the "|".  Everything that appears before it is renamed in
    -- rnFamDecl.
    rnInjectivityAnn :: LHsQTyVars GhcRn           -- ^ Type variables declared in
                                                   --   type family head
                     -> LFamilyResultSig GhcRn     -- ^ Result signature
                     -> LInjectivityAnn GhcPs      -- ^ Injectivity annotation
                     -> RnM (LInjectivityAnn GhcRn)
    rnInjectivityAnn :: LHsQTyVars GhcRn
    -> LFamilyResultSig GhcRn
    -> LInjectivityAnn GhcPs
    -> RnM (LInjectivityAnn GhcRn)
    rnInjectivityAnn LHsQTyVars GhcRn
    tvBndrs (L EpAnnCO
    _ (TyVarSig XTyVarSig GhcRn
    _ LHsTyVarBndr () GhcRn
    resTv))
                     (L EpAnnCO
    srcSpan (InjectivityAnn XCInjectivityAnn GhcPs
    x LIdP GhcPs
    injFrom [LIdP GhcPs]
    injTo))
     = do
       { (injDecl'@(L _ (InjectivityAnn _ injFrom' injTo')), noRnErrors)
              <- IOEnv
      (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool)
    forall a. TcRn a -> TcRn (a, Bool)
    askNoErrs (IOEnv
       (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
     -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool)
    forall a b. (a -> b) -> a -> b
    $
                 [Name]
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    forall a. [Name] -> RnM a -> RnM a
    bindLocalNames [LHsTyVarBndr () GhcRn -> IdP GhcRn
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
    hsLTyVarName LHsTyVarBndr () GhcRn
    resTv] (IOEnv
       (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
     -> IOEnv
          (Env TcGblEnv TcLclEnv)
          (GenLocated EpAnnCO (InjectivityAnn GhcRn)))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    forall a b. (a -> b) -> a -> b
    $
                 -- The return type variable scopes over the injectivity annotation
                 -- e.g.   type family F a = (r::*) | r -> a
                 do { injFrom' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    rnLTyVar LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    injFrom
                    ; injTo'   <- mapM rnLTyVar injTo
                    -- Note: srcSpan is unchanged, but typechecker gets
                    -- confused, l2l call makes it happy
                    ; return $ L (l2l srcSpan) (InjectivityAnn x injFrom' injTo') }

       ; let tvNames  = [Name] -> Set Name
    forall a. Ord a => [a] -> Set a
    Set.fromList ([Name] -> Set Name) -> [Name] -> Set Name
    forall a b. (a -> b) -> a -> b
    $ LHsQTyVars GhcRn -> [Name]
    hsAllLTyVarNames LHsQTyVars GhcRn
    tvBndrs
             resName  = LHsTyVarBndr () GhcRn -> IdP GhcRn
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
    hsLTyVarName LHsTyVarBndr () GhcRn
    resTv
             -- See Note [Renaming injectivity annotation]
             lhsValid = Ordering
    EQ Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == (Name -> Name -> Ordering
    stableNameCmp IdP GhcRn
    Name
    resName (GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LIdP GhcRn
    GenLocated SrcSpanAnnN Name
    injFrom'))
             rhsValid = [Name] -> Set Name
    forall a. Ord a => [a] -> Set a
    Set.fromList ((GenLocated SrcSpanAnnN Name -> Name)
    -> [GenLocated SrcSpanAnnN Name] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc [LIdP GhcRn]
    [GenLocated SrcSpanAnnN Name]
    injTo') Set Name -> Set Name -> Set Name
    forall a. Ord a => Set a -> Set a -> Set a
    `Set.difference` Set Name
    tvNames

       -- if renaming of type variables ended with errors (eg. there were
       -- not-in-scope variables) don't check the validity of injectivity
       -- annotation. This gives better error messages.
       ; when (noRnErrors && not lhsValid) $
            addErrAt (getLocA injFrom) $
              TcRnIncorrectTyVarOnLhsOfInjCond resName injFrom

       ; when (noRnErrors && not (Set.null rhsValid)) $
          do { let errorVars = Set Name -> [Name]
    forall a. Set a -> [a]
    Set.toList Set Name
    rhsValid
             ; addErrAt (locA srcSpan) $
                  TcRnUnknownTyVarsOnRhsOfInjCond errorVars }

       ; return injDecl' }

    -- We can only hit this case when the user writes injectivity annotation without
    -- naming the result:
    --
    --   type family F a | result -> a
    --   type family F a :: * | result -> a
    --
    -- So we rename injectivity annotation like we normally would except that
    -- this time we expect "result" to be reported not in scope by rnLTyVar.
    rnInjectivityAnn LHsQTyVars GhcRn
    _ LFamilyResultSig GhcRn
    _ (L EpAnnCO
    srcSpan (InjectivityAnn XCInjectivityAnn GhcPs
    x LIdP GhcPs
    injFrom [LIdP GhcPs]
    injTo)) =
       EpAnnCO
    -> RnM (LInjectivityAnn GhcRn) -> RnM (LInjectivityAnn GhcRn)
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA EpAnnCO
    srcSpan (RnM (LInjectivityAnn GhcRn) -> RnM (LInjectivityAnn GhcRn))
    -> RnM (LInjectivityAnn GhcRn) -> RnM (LInjectivityAnn GhcRn)
    forall a b. (a -> b) -> a -> b
    $ do
       (injDecl', _) <- IOEnv
      (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool)
    forall a. TcRn a -> TcRn (a, Bool)
    askNoErrs (IOEnv
       (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
     -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool))
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated EpAnnCO (InjectivityAnn GhcRn))
    -> TcRn (GenLocated EpAnnCO (InjectivityAnn GhcRn), Bool)
    forall a b. (a -> b) -> a -> b
    $ do
         injFrom' <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    rnLTyVar LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    injFrom
         injTo'   <- mapM rnLTyVar injTo
         return $ L srcSpan (InjectivityAnn x injFrom' injTo')
       return $ injDecl'

    {-
    Note [Stupid theta]
    ~~~~~~~~~~~~~~~~~~~
    #3850 complains about a regression wrt 6.10 for
         data Show a => T a
    There is no reason not to allow the stupid theta if there are no data
    constructors.  It's still stupid, but does no harm, and I don't want
    to cause programs to break unnecessarily (notably HList).  So if there
    are no data constructors we allow h98_style = True
    -}

    {- *****************************************************
    *                                                      *
         Support code for type/data declarations
    *                                                      *
    ***************************************************** -}

    -----------------
    rnConDecls :: DataDefnCons (LConDecl GhcPs) -> RnM (DataDefnCons (LConDecl GhcRn), FreeVars)
    rnConDecls :: DataDefnCons (LConDecl GhcPs)
    -> RnM (DataDefnCons (LConDecl GhcRn), FreeVars)
    rnConDecls = (GenLocated SrcSpanAnnA (ConDecl GhcPs)
     -> RnM (GenLocated SrcSpanAnnA (ConDecl GhcRn), FreeVars))
    -> DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcPs))
    -> RnM
         (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl GhcRn)), FreeVars)
    forall (f :: * -> *) a b.
    Traversable f =>
    (a -> RnM (b, FreeVars)) -> f a -> RnM (f b, FreeVars)
    mapFvRn ((ConDecl GhcPs -> TcM (ConDecl GhcRn, FreeVars))
    -> GenLocated SrcSpanAnnA (ConDecl GhcPs)
    -> RnM (GenLocated SrcSpanAnnA (ConDecl GhcRn), FreeVars)
    forall a b c ann.
    (a -> TcM (b, c))
    -> GenLocated (EpAnn ann) a -> TcM (GenLocated (EpAnn ann) b, c)
    wrapLocFstMA ConDecl GhcPs -> TcM (ConDecl GhcRn, FreeVars)
    rnConDecl)

    rnConDecl :: ConDecl GhcPs -> RnM (ConDecl GhcRn, FreeVars)
    rnConDecl :: ConDecl GhcPs -> TcM (ConDecl GhcRn, FreeVars)
    rnConDecl decl :: ConDecl GhcPs
    decl@(ConDeclH98 { con_name :: forall pass. ConDecl pass -> LIdP pass
    con_name = LIdP GhcPs
    name, con_ex_tvs :: forall pass. ConDecl pass -> [LHsTyVarBndr Specificity pass]
    con_ex_tvs = [LHsTyVarBndr Specificity GhcPs]
    ex_tvs
                               , con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
    con_mb_cxt = Maybe (LHsContext GhcPs)
    mcxt, con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = HsConDeclH98Details GhcPs
    args
                               , con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
    con_doc = Maybe (LHsDoc GhcPs)
    mb_doc, con_forall :: forall pass. ConDecl pass -> Bool
    con_forall = Bool
    forall_ })
      = do  { _        <- (RdrName -> TcRn ()) -> GenLocated SrcSpanAnnN RdrName -> TcRn ()
    forall t a b. HasLoc t => (a -> TcM b) -> GenLocated t a -> TcM b
    addLocM RdrName -> TcRn ()
    checkConName LIdP GhcPs
    GenLocated SrcSpanAnnN RdrName
    name
            ; new_name <- lookupLocatedTopConstructorRnN name

            -- We bind no implicit binders here; this is just like
            -- a nested HsForAllTy.  E.g. consider
            --         data T a = forall (b::k). MkT (...)
            -- The 'k' will already be in scope from the bindHsQTyVars
            -- for the data decl itself. So we'll get
            --         data T {k} a = ...
            -- And indeed we may later discover (a::k).  But that's the
            -- scoping we get.  So no implicit binders at the existential forall

            ; let ctxt = [GenLocated SrcSpanAnnN Name] -> HsDocContext
    ConDeclCtx [GenLocated SrcSpanAnnN Name
    new_name]
            ; bindLHsTyVarBndrs ctxt WarnUnusedForalls
                                Nothing ex_tvs $ \ [LHsTyVarBndr Specificity GhcRn]
    new_ex_tvs ->
        do  { (new_context, fvs1) <- HsDocContext
    -> Maybe (LHsContext GhcPs)
    -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMbContext HsDocContext
    ctxt Maybe (LHsContext GhcPs)
    mcxt
            ; (new_args,    fvs2) <- rnConDeclH98Details (unLoc new_name) ctxt args
            ; let all_fvs  = FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs2
            ; traceRn "rnConDecl (ConDeclH98)" (ppr name <+> vcat
                 [ text "ex_tvs:" <+> ppr ex_tvs
                 , text "new_ex_dqtvs':" <+> ppr new_ex_tvs ])

            ; mb_doc' <- traverse rnLHsDoc mb_doc
            ; return (decl { con_ext = noExtField
                           , con_name = new_name, con_ex_tvs = new_ex_tvs
                           , con_mb_cxt = new_context, con_args = new_args
                           , con_doc = mb_doc'
                           , con_forall = forall_ }, -- Remove when #18311 is fixed
                      all_fvs) }}

    rnConDecl (ConDeclGADT { con_names :: forall pass. ConDecl pass -> NonEmpty (LIdP pass)
    con_names   = NonEmpty (LIdP GhcPs)
    names
                           , con_bndrs :: forall pass. ConDecl pass -> XRec pass (HsOuterSigTyVarBndrs pass)
    con_bndrs   = L SrcSpanAnnA
    l HsOuterSigTyVarBndrs GhcPs
    outer_bndrs
                           , con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
    con_mb_cxt  = Maybe (LHsContext GhcPs)
    mcxt
                           , con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
    con_g_args  = HsConDeclGADTDetails GhcPs
    args
                           , con_res_ty :: forall pass. ConDecl pass -> LHsType pass
    con_res_ty  = LHsType GhcPs
    res_ty
                           , con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
    con_doc     = Maybe (LHsDoc GhcPs)
    mb_doc })
      = do  { (GenLocated SrcSpanAnnN RdrName -> TcRn ())
    -> NonEmpty (GenLocated SrcSpanAnnN RdrName) -> TcRn ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ ((RdrName -> TcRn ()) -> GenLocated SrcSpanAnnN RdrName -> TcRn ()
    forall t a b. HasLoc t => (a -> TcM b) -> GenLocated t a -> TcM b
    addLocM RdrName -> TcRn ()
    checkConName) NonEmpty (LIdP GhcPs)
    NonEmpty (GenLocated SrcSpanAnnN RdrName)
    names
            ; new_names <- (GenLocated SrcSpanAnnN RdrName
     -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name))
    -> NonEmpty (GenLocated SrcSpanAnnN RdrName)
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (NonEmpty (GenLocated SrcSpanAnnN Name))
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NonEmpty a -> m (NonEmpty b)
    mapM (GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    lookupLocatedTopConstructorRnN) NonEmpty (LIdP GhcPs)
    NonEmpty (GenLocated SrcSpanAnnN RdrName)
    names

            ; let -- We must ensure that we extract the free tkvs in left-to-right
                  -- order of their appearance in the constructor type.
                  -- That order governs the order the implicitly-quantified type
                  -- variable, and hence the order needed for visible type application
                  -- See #14808.
                  implicit_bndrs =
                    HsOuterSigTyVarBndrs GhcPs -> FreeKiTyVars -> FreeKiTyVars
    forall flag.
    HsOuterTyVarBndrs flag GhcPs -> FreeKiTyVars -> FreeKiTyVars
    extractHsOuterTvBndrs HsOuterSigTyVarBndrs GhcPs
    outer_bndrs           (FreeKiTyVars -> FreeKiTyVars) -> FreeKiTyVars -> FreeKiTyVars
    forall a b. (a -> b) -> a -> b
    $
                    [LHsType GhcPs] -> FreeKiTyVars -> FreeKiTyVars
    extractHsTysRdrTyVars (Maybe (LHsContext GhcPs) -> [LHsType GhcPs]
    forall (p :: Pass).
    Maybe (LHsContext (GhcPass p)) -> HsContext (GhcPass p)
    hsConDeclTheta Maybe (LHsContext GhcPs)
    mcxt) (FreeKiTyVars -> FreeKiTyVars) -> FreeKiTyVars -> FreeKiTyVars
    forall a b. (a -> b) -> a -> b
    $
                    HsConDeclGADTDetails GhcPs -> FreeKiTyVars -> FreeKiTyVars
    extractConDeclGADTDetailsTyVars HsConDeclGADTDetails GhcPs
    args        (FreeKiTyVars -> FreeKiTyVars) -> FreeKiTyVars -> FreeKiTyVars
    forall a b. (a -> b) -> a -> b
    $
                    [LHsType GhcPs] -> FreeKiTyVars -> FreeKiTyVars
    extractHsTysRdrTyVars [LHsType GhcPs
    res_ty] []

            ; let ctxt = [GenLocated SrcSpanAnnN Name] -> HsDocContext
    ConDeclCtx (NonEmpty (GenLocated SrcSpanAnnN Name)
    -> [GenLocated SrcSpanAnnN Name]
    forall a. NonEmpty a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList NonEmpty (GenLocated SrcSpanAnnN Name)
    new_names)

            ; bindHsOuterTyVarBndrs ctxt Nothing implicit_bndrs outer_bndrs $ \HsOuterTyVarBndrs Specificity GhcRn
    outer_bndrs' ->
        do  { (new_cxt, fvs1)    <- HsDocContext
    -> Maybe (LHsContext GhcPs)
    -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMbContext HsDocContext
    ctxt Maybe (LHsContext GhcPs)
    mcxt
            ; (new_args, fvs2)   <- rnConDeclGADTDetails (unLoc (head new_names)) ctxt args
            ; (new_res_ty, fvs3) <- rnLHsType ctxt res_ty

             -- Ensure that there are no nested `forall`s or contexts, per
             -- Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts)
             -- in GHC.Hs.Type.
           ; addNoNestedForallsContextsErr ctxt
               NFC_GadtConSig new_res_ty

            ; let all_fvs = FreeVars
    fvs1 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs2 FreeVars -> FreeVars -> FreeVars
    `plusFV` FreeVars
    fvs3

            ; traceRn "rnConDecl (ConDeclGADT)"
                (ppr names $$ ppr outer_bndrs')
            ; new_mb_doc <- traverse rnLHsDoc mb_doc
            ; return (ConDeclGADT { con_g_ext = noExtField, con_names = new_names
                                  , con_bndrs = L l outer_bndrs', con_mb_cxt = new_cxt
                                  , con_g_args = new_args, con_res_ty = new_res_ty
                                  , con_doc = new_mb_doc },
                      all_fvs) } }

    rnMbContext :: HsDocContext -> Maybe (LHsContext GhcPs)
                -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMbContext :: HsDocContext
    -> Maybe (LHsContext GhcPs)
    -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMbContext HsDocContext
    _    Maybe (LHsContext GhcPs)
    Nothing    = (Maybe
       (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]),
     FreeVars)
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (Maybe
            (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]),
          FreeVars)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe
      (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)])
    forall a. Maybe a
    Nothing, FreeVars
    emptyFVs)
    rnMbContext HsDocContext
    doc Maybe (LHsContext GhcPs)
    cxt = do { (ctx',fvs) <- HsDocContext
    -> Maybe (LHsContext GhcPs)
    -> RnM (Maybe (LHsContext GhcRn), FreeVars)
    rnMaybeContext HsDocContext
    doc Maybe (LHsContext GhcPs)
    cxt
                             ; return (ctx',fvs) }

    rnConDeclH98Details ::
          Name
       -> HsDocContext
       -> HsConDeclH98Details GhcPs
       -> RnM (HsConDeclH98Details GhcRn, FreeVars)
    rnConDeclH98Details :: Name
    -> HsDocContext
    -> HsConDeclH98Details GhcPs
    -> RnM (HsConDeclH98Details GhcRn, FreeVars)
    rnConDeclH98Details Name
    _ HsDocContext
    doc (PrefixCon [Void]
    _ [HsScaled GhcPs (LHsType GhcPs)]
    tys)
      = do { (new_tys, fvs) <- (HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))
     -> RnM
          (HsScaled GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars))
    -> [HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))]
    -> RnM
         ([HsScaled GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn))],
          FreeVars)
    forall (f :: * -> *) a b.
    Traversable f =>
    (a -> RnM (b, FreeVars)) -> f a -> RnM (f b, FreeVars)
    mapFvRn (HsDocContext
    -> HsScaled GhcPs (LHsType GhcPs)
    -> RnM (HsScaled GhcRn (LHsType GhcRn), FreeVars)
    rnScaledLHsType HsDocContext
    doc) [HsScaled GhcPs (LHsType GhcPs)]
    [HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))]
    tys
           ; return (PrefixCon noTypeArgs new_tys, fvs) }
    rnConDeclH98Details Name
    _ HsDocContext
    doc (InfixCon HsScaled GhcPs (LHsType GhcPs)
    ty1 HsScaled GhcPs (LHsType GhcPs)
    ty2)
      = do { (new_ty1, fvs1) <- HsDocContext
    -> HsScaled GhcPs (LHsType GhcPs)
    -> RnM (HsScaled GhcRn (LHsType GhcRn), FreeVars)
    rnScaledLHsType HsDocContext
    doc HsScaled GhcPs (LHsType GhcPs)
    ty1
           ; (new_ty2, fvs2) <- rnScaledLHsType doc ty2
           ; return (InfixCon new_ty1 new_ty2, fvs1 `plusFV` fvs2) }
    rnConDeclH98Details Name
    con HsDocContext
    doc (RecCon XRec GhcPs [XRec GhcPs (ConDeclField GhcPs)]
    flds)
      = do { (new_flds, fvs) <- Name
    -> HsDocContext
    -> GenLocated SrcSpanAnnL [XRec GhcPs (ConDeclField GhcPs)]
    -> RnM (LocatedL [LConDeclField GhcRn], FreeVars)
    rnRecConDeclFields Name
    con HsDocContext
    doc XRec GhcPs [XRec GhcPs (ConDeclField GhcPs)]
    GenLocated SrcSpanAnnL [XRec GhcPs (ConDeclField GhcPs)]
    flds
           ; return (RecCon new_flds, fvs) }

    rnConDeclGADTDetails ::
          Name
       -> HsDocContext
       -> HsConDeclGADTDetails GhcPs
       -> RnM (HsConDeclGADTDetails GhcRn, FreeVars)
    rnConDeclGADTDetails :: Name
    -> HsDocContext
    -> HsConDeclGADTDetails GhcPs
    -> RnM (HsConDeclGADTDetails GhcRn, FreeVars)
    rnConDeclGADTDetails Name
    _ HsDocContext
    doc (PrefixConGADT XPrefixConGADT GhcPs
    _ [HsScaled GhcPs (LHsType GhcPs)]
    tys)
      = do { (new_tys, fvs) <- (HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))
     -> RnM
          (HsScaled GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn)), FreeVars))
    -> [HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))]
    -> RnM
         ([HsScaled GhcRn (GenLocated SrcSpanAnnA (HsType GhcRn))],
          FreeVars)
    forall (f :: * -> *) a b.
    Traversable f =>
    (a -> RnM (b, FreeVars)) -> f a -> RnM (f b, FreeVars)
    mapFvRn (HsDocContext
    -> HsScaled GhcPs (LHsType GhcPs)
    -> RnM (HsScaled GhcRn (LHsType GhcRn), FreeVars)
    rnScaledLHsType HsDocContext
    doc) [HsScaled GhcPs (LHsType GhcPs)]
    [HsScaled GhcPs (GenLocated SrcSpanAnnA (HsType GhcPs))]
    tys
           ; return (PrefixConGADT noExtField new_tys, fvs) }
    rnConDeclGADTDetails Name
    con HsDocContext
    doc (RecConGADT XRecConGADT GhcPs
    _ XRec GhcPs [XRec GhcPs (ConDeclField GhcPs)]
    flds)
      = do { (new_flds, fvs) <- Name
    -> HsDocContext
    -> GenLocated SrcSpanAnnL [XRec GhcPs (ConDeclField GhcPs)]
    -> RnM (LocatedL [LConDeclField GhcRn], FreeVars)
    rnRecConDeclFields Name
    con HsDocContext
    doc XRec GhcPs [XRec GhcPs (ConDeclField GhcPs)]
    GenLocated SrcSpanAnnL [XRec GhcPs (ConDeclField GhcPs)]
    flds
           ; return (RecConGADT noExtField new_flds, fvs) }

    rnRecConDeclFields ::
         Name
      -> HsDocContext
      -> LocatedL [LConDeclField GhcPs]
      -> RnM (LocatedL [LConDeclField GhcRn], FreeVars)
    rnRecConDeclFields :: Name
    -> HsDocContext
    -> GenLocated SrcSpanAnnL [XRec GhcPs (ConDeclField GhcPs)]
    -> RnM (LocatedL [LConDeclField GhcRn], FreeVars)
    rnRecConDeclFields Name
    con HsDocContext
    doc (L SrcSpanAnnL
    l [XRec GhcPs (ConDeclField GhcPs)]
    fields)
      = do  { fls <- HasDebugCallStack => Name -> RnM [FieldLabel]
    Name -> RnM [FieldLabel]
    lookupConstructorFields Name
    con
            ; (new_fields, fvs) <- rnConDeclFields doc fls fields
                    -- No need to check for duplicate fields
                    -- since that is done by GHC.Rename.Names.extendGlobalRdrEnvRn
            ; pure (L l new_fields, fvs) }

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

    -- | Brings pattern synonym names and also pattern synonym selectors
    -- from record pattern synonyms into scope.
    extendPatSynEnv :: DuplicateRecordFields -> FieldSelectors -> HsValBinds GhcPs -> MiniFixityEnv
                    -> ([Name] -> TcRnIf TcGblEnv TcLclEnv a) -> TcM a
    extendPatSynEnv :: forall a.
    DuplicateRecordFields
    -> FieldSelectors
    -> HsValBinds GhcPs
    -> MiniFixityEnv
    -> ([Name] -> TcRnIf TcGblEnv TcLclEnv a)
    -> TcRnIf TcGblEnv TcLclEnv a
    extendPatSynEnv DuplicateRecordFields
    dup_fields_ok FieldSelectors
    has_sel HsValBinds GhcPs
    val_decls MiniFixityEnv
    local_fix_env [Name] -> TcRnIf TcGblEnv TcLclEnv a
    thing = do {
         names_with_fls <- HsValBinds GhcPs -> TcM [(ConLikeName, ConInfo)]
    new_ps HsValBinds GhcPs
    val_decls
       ; let pat_syn_bndrs = [[Name]] -> [Name]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [ ConLikeName -> Name
    conLikeName_Name ConLikeName
    name Name -> [Name] -> [Name]
    forall a. a -> [a] -> [a]
    : (FieldLabel -> Name) -> [FieldLabel] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map FieldLabel -> Name
    flSelector [FieldLabel]
    flds
                                    | (ConLikeName
    name, ConInfo
    con_info) <- [(ConLikeName, ConInfo)]
    names_with_fls
                                    , let flds :: [FieldLabel]
    flds = ConInfo -> [FieldLabel]
    conInfoFields ConInfo
    con_info ]
       ; let gres =  ((ConLikeName, ConInfo) -> GlobalRdrEltX GREInfo)
    -> [(ConLikeName, ConInfo)] -> [GlobalRdrEltX GREInfo]
    forall a b. (a -> b) -> [a] -> [b]
    map (Parent -> (ConLikeName, ConInfo) -> GlobalRdrEltX GREInfo
    mkLocalConLikeGRE Parent
    NoParent) [(ConLikeName, ConInfo)]
    names_with_fls
                  [GlobalRdrEltX GREInfo]
    -> [GlobalRdrEltX GREInfo] -> [GlobalRdrEltX GREInfo]
    forall a. [a] -> [a] -> [a]
    ++ Parent -> [(ConLikeName, ConInfo)] -> [GlobalRdrEltX GREInfo]
    mkLocalFieldGREs Parent
    NoParent [(ConLikeName, ConInfo)]
    names_with_fls
          -- Recall Note [Parents] in GHC.Types.Name.Reader:
          --
          -- pattern synonym constructors and their record fields have no parent
          -- in the module in which they are defined.
       ; (gbl_env, lcl_env) <- extendGlobalRdrEnvRn gres local_fix_env
       ; restoreEnvs (gbl_env, lcl_env) (thing pat_syn_bndrs) }
      where

        new_ps :: HsValBinds GhcPs -> TcM [(ConLikeName, ConInfo)]
        new_ps :: HsValBinds GhcPs -> TcM [(ConLikeName, ConInfo)]
    new_ps (ValBinds XValBinds GhcPs GhcPs
    _ LHsBinds GhcPs
    binds [LSig GhcPs]
    _) = (GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs)
     -> [(ConLikeName, ConInfo)] -> TcM [(ConLikeName, ConInfo)])
    -> [(ConLikeName, ConInfo)]
    -> Bag (GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs))
    -> TcM [(ConLikeName, ConInfo)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> b -> m b) -> b -> t a -> m b
    foldrM LHsBindLR GhcPs GhcPs
    -> [(ConLikeName, ConInfo)] -> TcM [(ConLikeName, ConInfo)]
    GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs)
    -> [(ConLikeName, ConInfo)] -> TcM [(ConLikeName, ConInfo)]
    new_ps' [] LHsBinds GhcPs
    Bag (GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs))
    binds
        new_ps HsValBinds GhcPs
    _ = String -> TcM [(ConLikeName, ConInfo)]
    forall a. HasCallStack => String -> a
    panic String
    "new_ps"

        new_ps' :: LHsBindLR GhcPs GhcPs
                -> [(ConLikeName, ConInfo)]
                -> TcM [(ConLikeName, ConInfo)]
        new_ps' :: LHsBindLR GhcPs GhcPs
    -> [(ConLikeName, ConInfo)] -> TcM [(ConLikeName, ConInfo)]
    new_ps' LHsBindLR GhcPs GhcPs
    bind [(ConLikeName, ConInfo)]
    names
          | (L SrcSpanAnnA
    bind_loc (PatSynBind XPatSynBind GhcPs GhcPs
    _ (PSB { psb_id :: forall idL idR. PatSynBind idL idR -> LIdP idL
    psb_id = L SrcSpanAnnN
    _ RdrName
    n
                                           , psb_args :: forall idL idR. PatSynBind idL idR -> HsPatSynDetails idR
    psb_args = RecCon [RecordPatSynField GhcPs]
    as }))) <- LHsBindLR GhcPs GhcPs
    bind
          = do
              bnd_name <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) Name
    newTopSrcBinder (SrcSpanAnnN -> RdrName -> GenLocated SrcSpanAnnN RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpanAnnA -> SrcSpanAnnN
    forall a b. (HasLoc a, HasAnnotation b) => a -> b
    l2l SrcSpanAnnA
    bind_loc) RdrName
    n)
              let field_occs = (RecordPatSynField GhcPs
     -> GenLocated SrcSpanAnnA (FieldOcc GhcPs))
    -> [RecordPatSynField GhcPs]
    -> [GenLocated SrcSpanAnnA (FieldOcc GhcPs)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((\ FieldOcc GhcPs
    f -> SrcSpanAnnA
    -> FieldOcc GhcPs -> GenLocated SrcSpanAnnA (FieldOcc GhcPs)
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcSpanAnnA
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan (SrcSpan -> SrcSpanAnnA) -> SrcSpan -> SrcSpanAnnA
    forall a b. (a -> b) -> a -> b
    $ GenLocated SrcSpanAnnN RdrName -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA (FieldOcc GhcPs -> XRec GhcPs RdrName
    forall pass. FieldOcc pass -> XRec pass RdrName
    foLabel FieldOcc GhcPs
    f)) FieldOcc GhcPs
    f) (FieldOcc GhcPs -> GenLocated SrcSpanAnnA (FieldOcc GhcPs))
    -> (RecordPatSynField GhcPs -> FieldOcc GhcPs)
    -> RecordPatSynField GhcPs
    -> GenLocated SrcSpanAnnA (FieldOcc GhcPs)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RecordPatSynField GhcPs -> FieldOcc GhcPs
    forall pass. RecordPatSynField pass -> FieldOcc pass
    recordPatSynField) [RecordPatSynField GhcPs]
    as
              flds <- mapM (newRecordFieldLabel dup_fields_ok has_sel [bnd_name]) field_occs
              let con_info = Int -> [FieldLabel] -> ConInfo
    mkConInfo (([RecordPatSynField GhcPs] -> Int)
    -> HsConDetails Any Any [RecordPatSynField GhcPs] -> Int
    forall rec tyarg arg.
    (rec -> Int) -> HsConDetails tyarg arg rec -> Int
    conDetailsArity [RecordPatSynField GhcPs] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length ([RecordPatSynField GhcPs]
    -> HsConDetails Any Any [RecordPatSynField GhcPs]
    forall tyarg arg rec. rec -> HsConDetails tyarg arg rec
    RecCon [RecordPatSynField GhcPs]
    as)) [FieldLabel]
    flds
              return ((PatSynName bnd_name, con_info) : names)
          | L SrcSpanAnnA
    bind_loc (PatSynBind XPatSynBind GhcPs GhcPs
    _ (PSB { psb_id :: forall idL idR. PatSynBind idL idR -> LIdP idL
    psb_id = L SrcSpanAnnN
    _ RdrName
    n, psb_args :: forall idL idR. PatSynBind idL idR -> HsPatSynDetails idR
    psb_args = HsConDetails Void (LIdP GhcPs) [RecordPatSynField GhcPs]
    as })) <- LHsBindLR GhcPs GhcPs
    bind
          = do
            bnd_name <- GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) Name
    newTopSrcBinder (SrcSpanAnnN -> RdrName -> GenLocated SrcSpanAnnN RdrName
    forall l e. l -> e -> GenLocated l e
    L (SrcSpanAnnA -> SrcSpanAnnN
    forall a b. (HasLoc a, HasAnnotation b) => a -> b
    l2l SrcSpanAnnA
    bind_loc) RdrName
    n)
            let con_info = Int -> [FieldLabel] -> ConInfo
    mkConInfo (([RecordPatSynField GhcPs] -> Int)
    -> HsConDetails
         Void (GenLocated SrcSpanAnnN RdrName) [RecordPatSynField GhcPs]
    -> Int
    forall rec tyarg arg.
    (rec -> Int) -> HsConDetails tyarg arg rec -> Int
    conDetailsArity [RecordPatSynField GhcPs] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length HsConDetails Void (LIdP GhcPs) [RecordPatSynField GhcPs]
    HsConDetails
      Void (GenLocated SrcSpanAnnN RdrName) [RecordPatSynField GhcPs]
    as) []
            return ((PatSynName bnd_name, con_info) : names)
          | Bool
    otherwise
          = [(ConLikeName, ConInfo)] -> TcM [(ConLikeName, ConInfo)]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [(ConLikeName, ConInfo)]
    names

    {-
    *********************************************************
    *                                                      *
    \subsection{Support code to rename types}
    *                                                      *
    *********************************************************
    -}

    rnFds :: [LHsFunDep GhcPs] -> RnM [LHsFunDep GhcRn]
    rnFds :: [LHsFunDep GhcPs] -> RnM [LHsFunDep GhcRn]
    rnFds [LHsFunDep GhcPs]
    fds
      = (GenLocated SrcSpanAnnA (FunDep GhcPs)
     -> IOEnv
          (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (FunDep GhcRn)))
    -> [GenLocated SrcSpanAnnA (FunDep GhcPs)]
    -> IOEnv
         (Env TcGblEnv TcLclEnv) [GenLocated SrcSpanAnnA (FunDep GhcRn)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((FunDep GhcPs -> TcM (FunDep GhcRn))
    -> GenLocated SrcSpanAnnA (FunDep GhcPs)
    -> IOEnv
         (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (FunDep GhcRn))
    forall a b ann.
    (a -> TcM b)
    -> GenLocated (EpAnn ann) a -> TcRn (GenLocated (EpAnn ann) b)
    wrapLocMA FunDep GhcPs -> TcM (FunDep GhcRn)
    rn_fds) [LHsFunDep GhcPs]
    [GenLocated SrcSpanAnnA (FunDep GhcPs)]
    fds
      where
        rn_fds :: FunDep GhcPs -> RnM (FunDep GhcRn)
        rn_fds :: FunDep GhcPs -> TcM (FunDep GhcRn)
    rn_fds (FunDep XCFunDep GhcPs
    x [LIdP GhcPs]
    tys1 [LIdP GhcPs]
    tys2)
          = do { tys1' <- FreeKiTyVars
    -> IOEnv (Env TcGblEnv TcLclEnv) [GenLocated SrcSpanAnnN Name]
    rnHsTyVars [LIdP GhcPs]
    FreeKiTyVars
    tys1
               ; tys2' <- rnHsTyVars tys2
               ; return (FunDep x tys1' tys2') }

    rnHsTyVars :: [LocatedN RdrName] -> RnM [LocatedN Name]
    rnHsTyVars :: FreeKiTyVars
    -> IOEnv (Env TcGblEnv TcLclEnv) [GenLocated SrcSpanAnnN Name]
    rnHsTyVars FreeKiTyVars
    tvs  = (GenLocated SrcSpanAnnN RdrName
     -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name))
    -> FreeKiTyVars
    -> IOEnv (Env TcGblEnv TcLclEnv) [GenLocated SrcSpanAnnN Name]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    rnHsTyVar FreeKiTyVars
    tvs

    rnHsTyVar :: LocatedN RdrName -> RnM (LocatedN Name)
    rnHsTyVar :: GenLocated SrcSpanAnnN RdrName
    -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
    rnHsTyVar (L SrcSpanAnnN
    l RdrName
    tyvar) = do
      tyvar' <- RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name
    lookupOccRn RdrName
    tyvar
      return (L l tyvar')

    {-
    *********************************************************
    *                                                      *
            findSplice
    *                                                      *
    *********************************************************

    This code marches down the declarations, looking for the first
    Template Haskell splice.  As it does so it
            a) groups the declarations into a HsGroup
            b) runs any top-level quasi-quotes
    -}

    findSplice :: [LHsDecl GhcPs]
               -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    findSplice :: [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    findSplice [LHsDecl GhcPs]
    ds = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl HsGroup GhcPs
    forall (p :: Pass). HsGroup (GhcPass p)
    emptyRdrGroup [LHsDecl GhcPs]
    ds

    addl :: HsGroup GhcPs -> [LHsDecl GhcPs]
         -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    -- This stuff reverses the declarations (again) but it doesn't matter
    addl :: HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl HsGroup GhcPs
    gp []           = (HsGroup GhcPs,
     Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)]))
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (HsGroup GhcPs,
          Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)]))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (HsGroup GhcPs
    gp, Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
    forall a. Maybe a
    Nothing)
    addl HsGroup GhcPs
    gp (L SrcSpanAnnA
    l HsDecl GhcPs
    d : [LHsDecl GhcPs]
    ds) = HsGroup GhcPs
    -> SrcSpanAnnA
    -> HsDecl GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    add HsGroup GhcPs
    gp SrcSpanAnnA
    l HsDecl GhcPs
    d [LHsDecl GhcPs]
    ds

    add :: HsGroup GhcPs -> SrcSpanAnnA -> HsDecl GhcPs -> [LHsDecl GhcPs]
        -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))

    -- #10047: Declaration QuasiQuoters are expanded immediately, without
    --         causing a group split
    add :: HsGroup GhcPs
    -> SrcSpanAnnA
    -> HsDecl GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    add HsGroup GhcPs
    gp SrcSpanAnnA
    _ (SpliceD XSpliceD GhcPs
    _ (SpliceDecl XSpliceDecl GhcPs
    _ (L SrcSpanAnnA
    _ qq :: HsUntypedSplice GhcPs
    qq@HsQuasiQuote{}) SpliceDecoration
    _)) [LHsDecl GhcPs]
    ds
      = do { (ds', _) <- HsUntypedSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars)
    rnTopSpliceDecls HsUntypedSplice GhcPs
    qq
           ; addl gp (ds' ++ ds)
           }

    add HsGroup GhcPs
    gp SrcSpanAnnA
    loc (SpliceD XSpliceD GhcPs
    _ splice :: SpliceDecl GhcPs
    splice@(SpliceDecl XSpliceDecl GhcPs
    _ XRec GhcPs (HsUntypedSplice GhcPs)
    _ SpliceDecoration
    flag)) [LHsDecl GhcPs]
    ds
      = do { -- We've found a top-level splice.  If it is an *implicit* one
             -- (i.e. a naked top level expression), throw an error if
             -- TemplateHaskell is not enabled.
             case SpliceDecoration
    flag of
               SpliceDecoration
    DollarSplice -> () -> TcRn ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
               SpliceDecoration
    BareSplice -> do { Extension -> TcRn () -> TcRn ()
    forall gbl lcl. Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
    unlessXOptM Extension
    LangExt.TemplateHaskell
                                (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ SrcSpan -> TcRn () -> TcRn ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (SrcSpanAnnA -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnA
    loc)
                                (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
    forall a b. (a -> b) -> a -> b
    $ TcRnMessage -> TcRn ()
    forall a. TcRnMessage -> TcM a
    failWith TcRnMessage
    badImplicitSplice }

           ; (HsGroup GhcPs,
     Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)]))
    -> IOEnv
         (Env TcGblEnv TcLclEnv)
         (HsGroup GhcPs,
          Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)]))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (HsGroup GhcPs
    gp, (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
    -> Maybe
         (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
    forall a. a -> Maybe a
    Just (SpliceDecl GhcPs
    splice, [LHsDecl GhcPs]
    [GenLocated SrcSpanAnnA (HsDecl GhcPs)]
    ds)) }
      where
        badImplicitSplice :: TcRnMessage
        badImplicitSplice :: TcRnMessage
    badImplicitSplice = THError -> TcRnMessage
    TcRnTHError (THSyntaxError -> THError
    THSyntaxError THSyntaxError
    BadImplicitSplice)

    -- Class declarations: added to the TyClGroup
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup GhcPs]
    ts}) SrcSpanAnnA
    l (TyClD XTyClD GhcPs
    _ TyClDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_tyclds = add_tycld (L l d) ts }) [LHsDecl GhcPs]
    ds

    -- Signatures: fixity sigs go a different place than all others
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds = [LFixitySig GhcPs]
    ts}) SrcSpanAnnA
    l (SigD XSigD GhcPs
    _ (FixSig XFixSig GhcPs
    _ FixitySig GhcPs
    f)) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp {hs_fixds = L l f : ts}) [LHsDecl GhcPs]
    ds

    -- Standalone kind signatures: added to the TyClGroup
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup GhcPs]
    ts}) SrcSpanAnnA
    l (KindSigD XKindSigD GhcPs
    _ StandaloneKindSig GhcPs
    s) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp {hs_tyclds = add_kisig (L l s) ts}) [LHsDecl GhcPs]
    ds

    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds = HsValBinds GhcPs
    ts}) SrcSpanAnnA
    l (SigD XSigD GhcPs
    _ Sig GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp {hs_valds = add_sig (L l d) ts}) [LHsDecl GhcPs]
    ds

    -- Value declarations: use add_bind
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds  = HsValBinds GhcPs
    ts}) SrcSpanAnnA
    l (ValD XValD GhcPs
    _ HsBindLR GhcPs GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_valds = add_bind (L l d) ts }) [LHsDecl GhcPs]
    ds

    -- Role annotations: added to the TyClGroup
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup GhcPs]
    ts}) SrcSpanAnnA
    l (RoleAnnotD XRoleAnnotD GhcPs
    _ RoleAnnotDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_tyclds = add_role_annot (L l d) ts }) [LHsDecl GhcPs]
    ds

    -- NB instance declarations go into TyClGroups. We throw them into the first
    -- group, just as we do for the TyClD case. The renamer will go on to group
    -- and order them later.
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup GhcPs]
    ts})  SrcSpanAnnA
    l (InstD XInstD GhcPs
    _ InstDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_tyclds = add_instd (L l d) ts }) [LHsDecl GhcPs]
    ds

    -- The rest are routine
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_derivds :: forall p. HsGroup p -> [LDerivDecl p]
    hs_derivds = [LDerivDecl GhcPs]
    ts})  SrcSpanAnnA
    l (DerivD XDerivD GhcPs
    _ DerivDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_derivds = L l d : ts }) [LHsDecl GhcPs]
    ds
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_defds :: forall p. HsGroup p -> [LDefaultDecl p]
    hs_defds  = [LDefaultDecl GhcPs]
    ts})  SrcSpanAnnA
    l (DefD XDefD GhcPs
    _ DefaultDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_defds = L l d : ts }) [LHsDecl GhcPs]
    ds
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_fords :: forall p. HsGroup p -> [LForeignDecl p]
    hs_fords  = [LForeignDecl GhcPs]
    ts}) SrcSpanAnnA
    l (ForD XForD GhcPs
    _ ForeignDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_fords = L l d : ts }) [LHsDecl GhcPs]
    ds
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_warnds :: forall p. HsGroup p -> [LWarnDecls p]
    hs_warnds  = [LWarnDecls GhcPs]
    ts})  SrcSpanAnnA
    l (WarningD XWarningD GhcPs
    _ WarnDecls GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_warnds = L l d : ts }) [LHsDecl GhcPs]
    ds
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_annds :: forall p. HsGroup p -> [LAnnDecl p]
    hs_annds  = [LAnnDecl GhcPs]
    ts}) SrcSpanAnnA
    l (AnnD XAnnD GhcPs
    _ AnnDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_annds = L l d : ts }) [LHsDecl GhcPs]
    ds
    add gp :: HsGroup GhcPs
    gp@(HsGroup {hs_ruleds :: forall p. HsGroup p -> [LRuleDecls p]
    hs_ruleds  = [LRuleDecls GhcPs]
    ts}) SrcSpanAnnA
    l (RuleD XRuleD GhcPs
    _ RuleDecls GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_ruleds = L l d : ts }) [LHsDecl GhcPs]
    ds
    add HsGroup GhcPs
    gp SrcSpanAnnA
    l (DocD XDocD GhcPs
    _ DocDecl GhcPs
    d) [LHsDecl GhcPs]
    ds
      = HsGroup GhcPs
    -> [LHsDecl GhcPs]
    -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
    addl (HsGroup GhcPs
    gp { hs_docs = (L l d) : (hs_docs gp) })  [LHsDecl GhcPs]
    ds

    add_tycld :: LTyClDecl (GhcPass p) -> [TyClGroup (GhcPass p)]
              -> [TyClGroup (GhcPass p)]
    add_tycld :: forall (p :: Pass).
    LTyClDecl (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    add_tycld LTyClDecl (GhcPass p)
    d []       = [TyClGroup { group_ext :: XCTyClGroup (GhcPass p)
    group_ext    = XCTyClGroup (GhcPass p)
    NoExtField
    noExtField
                                      , group_tyclds :: [LTyClDecl (GhcPass p)]
    group_tyclds = [LTyClDecl (GhcPass p)
    d]
                                      , group_kisigs :: [LStandaloneKindSig (GhcPass p)]
    group_kisigs = []
                                      , group_roles :: [LRoleAnnotDecl (GhcPass p)]
    group_roles  = []
                                      , group_instds :: [LInstDecl (GhcPass p)]
    group_instds = []
                                      }
                           ]
    add_tycld LTyClDecl (GhcPass p)
    d (ds :: TyClGroup (GhcPass p)
    ds@(TyClGroup { group_tyclds :: forall pass. TyClGroup pass -> [LTyClDecl pass]
    group_tyclds = [LTyClDecl (GhcPass p)]
    tyclds }):[TyClGroup (GhcPass p)]
    dss)
      = TyClGroup (GhcPass p)
    ds { group_tyclds = d : tyclds } TyClGroup (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    forall a. a -> [a] -> [a]
    : [TyClGroup (GhcPass p)]
    dss

    add_instd :: LInstDecl (GhcPass p) -> [TyClGroup (GhcPass p)]
              -> [TyClGroup (GhcPass p)]
    add_instd :: forall (p :: Pass).
    LInstDecl (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    add_instd LInstDecl (GhcPass p)
    d []       = [TyClGroup { group_ext :: XCTyClGroup (GhcPass p)
    group_ext    = XCTyClGroup (GhcPass p)
    NoExtField
    noExtField
                                      , group_tyclds :: [LTyClDecl (GhcPass p)]
    group_tyclds = []
                                      , group_kisigs :: [LStandaloneKindSig (GhcPass p)]
    group_kisigs = []
                                      , group_roles :: [LRoleAnnotDecl (GhcPass p)]
    group_roles  = []
                                      , group_instds :: [LInstDecl (GhcPass p)]
    group_instds = [LInstDecl (GhcPass p)
    d]
                                      }
                           ]
    add_instd LInstDecl (GhcPass p)
    d (ds :: TyClGroup (GhcPass p)
    ds@(TyClGroup { group_instds :: forall pass. TyClGroup pass -> [LInstDecl pass]
    group_instds = [LInstDecl (GhcPass p)]
    instds }):[TyClGroup (GhcPass p)]
    dss)
      = TyClGroup (GhcPass p)
    ds { group_instds = d : instds } TyClGroup (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    forall a. a -> [a] -> [a]
    : [TyClGroup (GhcPass p)]
    dss

    add_role_annot :: LRoleAnnotDecl (GhcPass p) -> [TyClGroup (GhcPass p)]
                   -> [TyClGroup (GhcPass p)]
    add_role_annot :: forall (p :: Pass).
    LRoleAnnotDecl (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    add_role_annot LRoleAnnotDecl (GhcPass p)
    d [] = [TyClGroup { group_ext :: XCTyClGroup (GhcPass p)
    group_ext    = XCTyClGroup (GhcPass p)
    NoExtField
    noExtField
                                     , group_tyclds :: [LTyClDecl (GhcPass p)]
    group_tyclds = []
                                     , group_kisigs :: [LStandaloneKindSig (GhcPass p)]
    group_kisigs = []
                                     , group_roles :: [LRoleAnnotDecl (GhcPass p)]
    group_roles  = [LRoleAnnotDecl (GhcPass p)
    d]
                                     , group_instds :: [LInstDecl (GhcPass p)]
    group_instds = []
                                     }
                          ]
    add_role_annot LRoleAnnotDecl (GhcPass p)
    d (tycls :: TyClGroup (GhcPass p)
    tycls@(TyClGroup { group_roles :: forall pass. TyClGroup pass -> [LRoleAnnotDecl pass]
    group_roles = [LRoleAnnotDecl (GhcPass p)]
    roles }) : [TyClGroup (GhcPass p)]
    rest)
      = TyClGroup (GhcPass p)
    tycls { group_roles = d : roles } TyClGroup (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    forall a. a -> [a] -> [a]
    : [TyClGroup (GhcPass p)]
    rest

    add_kisig :: LStandaloneKindSig (GhcPass p)
             -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    add_kisig :: forall (p :: Pass).
    LStandaloneKindSig (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    add_kisig LStandaloneKindSig (GhcPass p)
    d [] = [TyClGroup { group_ext :: XCTyClGroup (GhcPass p)
    group_ext    = XCTyClGroup (GhcPass p)
    NoExtField
    noExtField
                                , group_tyclds :: [LTyClDecl (GhcPass p)]
    group_tyclds = []
                                , group_kisigs :: [LStandaloneKindSig (GhcPass p)]
    group_kisigs = [LStandaloneKindSig (GhcPass p)
    d]
                                , group_roles :: [LRoleAnnotDecl (GhcPass p)]
    group_roles  = []
                                , group_instds :: [LInstDecl (GhcPass p)]
    group_instds = []
                                }
                     ]
    add_kisig LStandaloneKindSig (GhcPass p)
    d (tycls :: TyClGroup (GhcPass p)
    tycls@(TyClGroup { group_kisigs :: forall pass. TyClGroup pass -> [LStandaloneKindSig pass]
    group_kisigs = [LStandaloneKindSig (GhcPass p)]
    kisigs }) : [TyClGroup (GhcPass p)]
    rest)
      = TyClGroup (GhcPass p)
    tycls { group_kisigs = d : kisigs } TyClGroup (GhcPass p)
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    forall a. a -> [a] -> [a]
    : [TyClGroup (GhcPass p)]
    rest

    add_bind :: LHsBind a -> HsValBinds a -> HsValBinds a
    add_bind :: forall a. LHsBind a -> HsValBinds a -> HsValBinds a
    add_bind LHsBind a
    b (ValBinds XValBinds a a
    x LHsBindsLR a a
    bs [LSig a]
    sigs) = XValBinds a a -> LHsBindsLR a a -> [LSig a] -> HsValBindsLR a a
    forall idL idR.
    XValBinds idL idR
    -> LHsBindsLR idL idR -> [LSig idR] -> HsValBindsLR idL idR
    ValBinds XValBinds a a
    x (LHsBindsLR a a
    bs LHsBindsLR a a -> LHsBind a -> LHsBindsLR a a
    forall a. Bag a -> a -> Bag a
    `snocBag` LHsBind a
    b) [LSig a]
    sigs
    add_bind LHsBind a
    _ (XValBindsLR {})     = String -> HsValBindsLR a a
    forall a. HasCallStack => String -> a
    panic String
    "GHC.Rename.Module.add_bind"

    add_sig :: LSig (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a)
    add_sig :: forall (a :: Pass).
    LSig (GhcPass a)
    -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a)
    add_sig LSig (GhcPass a)
    s (ValBinds XValBinds (GhcPass a) (GhcPass a)
    x LHsBindsLR (GhcPass a) (GhcPass a)
    bs [LSig (GhcPass a)]
    sigs) = XValBinds (GhcPass a) (GhcPass a)
    -> LHsBindsLR (GhcPass a) (GhcPass a)
    -> [LSig (GhcPass a)]
    -> HsValBindsLR (GhcPass a) (GhcPass a)
    forall idL idR.
    XValBinds idL idR
    -> LHsBindsLR idL idR -> [LSig idR] -> HsValBindsLR idL idR
    ValBinds XValBinds (GhcPass a) (GhcPass a)
    x LHsBindsLR (GhcPass a) (GhcPass a)
    bs (LSig (GhcPass a)
    GenLocated SrcSpanAnnA (Sig (GhcPass a))
    sGenLocated SrcSpanAnnA (Sig (GhcPass a))
    -> [GenLocated SrcSpanAnnA (Sig (GhcPass a))]
    -> [GenLocated SrcSpanAnnA (Sig (GhcPass a))]
    forall a. a -> [a] -> [a]
    :[LSig (GhcPass a)]
    [GenLocated SrcSpanAnnA (Sig (GhcPass a))]
    sigs)
    add_sig LSig (GhcPass a)
    _ (XValBindsLR {})     = String -> HsValBindsLR (GhcPass a) (GhcPass a)
    forall a. HasCallStack => String -> a
    panic String
    "GHC.Rename.Module.add_sig"