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

{-# 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.Types.Basic (Arity)
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.GREInfo (ConLikeInfo (..), ConInfo, mkConInfo, conInfoFields)
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, maybeToList )
import qualified Data.Set as Set ( difference, fromList, toList, null )

{- | @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@(XValBindsLR (NValBinds _ sigs')), 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 ;

   -- Update the TcGblEnv with renamed COMPLETE pragmas from the current
   -- module, for pattern irrefutability checking in do notation.
   last_tcg_env0 <- getGblEnv ;
   let { last_tcg_env =
            TcGblEnv
last_tcg_env0
              { tcg_complete_matches = tcg_complete_matches last_tcg_env0 ++ localCompletePragmas sigs' }
       } ;
   -- (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, (EpToken "[", EpToken "]")
_) [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, (EpToken "[", EpToken "]")
_) [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
_ Maybe (LIdP GhcPs)
mb_cls [LHsType GhcPs]
tys)
  = do {
       ; mb_cls' <- (GenLocated SrcSpanAnnN RdrName
 -> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name))
-> Maybe (GenLocated SrcSpanAnnN RdrName)
-> IOEnv
     (Env TcGblEnv TcLclEnv) (Maybe (GenLocated SrcSpanAnnN Name))
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) -> Maybe a -> f (Maybe b)
traverse ((RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name)
-> GenLocated SrcSpanAnnN RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnN Name)
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 SrcSpanAnnN a -> f (GenLocated SrcSpanAnnN b)
traverse RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name
lookupOccRn) Maybe (LIdP GhcPs)
Maybe (GenLocated SrcSpanAnnN RdrName)
mb_cls
       ; (tys', ty_fvs) <- rnLHsTypes doc_str tys
       ; return (DefaultDecl noExtField mb_cls' tys', ty_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_ LHsBinds GhcRn
[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_ LHsBinds GhcRn
[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_ LHsBinds GhcRn
[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_ LHsBinds GhcRn
[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 SrcSpanAnnLW
_ [L SrcSpanAnnA
_ (Match { m_pats :: forall p body. Match p body -> XRec p [LPat p]
m_pats = L EpaLocation
_ []
                                             , 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, AnnClsInstDecl
_, 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, AnnDerivDecl
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')
       ; inst_warn_rn <- mapM rnLWarningTxt inst_warn_ps
       ; return (DerivDecl (inst_warn_rn, ann) ty' mds' overlap, fvs) }
  where
    ctxt :: HsDocContext
ctxt    = HsDocContext
DerivDeclCtx
    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 = ((EpaLocation, EpToken "#-}")
_, 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 XCRuleBndr GhcRn
AnnTyVarBndr
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 XRuleBndrSig GhcRn
AnnTyVarBndr
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 (ZonkAny 5)
-> [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 (ZonkAny 5)
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.

Note [Parens on the LHS of a RULE]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
You may think that no one would write

   {-# RULES "foo" (f True) = blah #-}

with the LHS wrapped in parens. But Template Haskell does (#24621)!
So we should accommodate them.
-}

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
    -- See Note [Parens on the LHS of a RULE]
    check (HsPar XPar GhcRn
_ LHsExpr GhcRn
e)                     = GenLocated SrcSpanAnnA (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
checkl LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
e
    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 (LConDecl GhcRn), FreeVars)
thing -> RnM (DataDefnCons (LConDecl GhcRn), FreeVars)
thing
                            | Bool
otherwise = LocalRdrEnv
-> RnM (DataDefnCons (LConDecl GhcRn), FreeVars)
-> RnM (DataDefnCons (LConDecl 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 = noAnn, 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
_ (HsBang 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 #24620 for an example of what happens if you accidentally include
     a wrapper.

     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.

-}

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
       ; 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 EpToken "via"
_ 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

       ; case hsBndrVar (unLoc tvbndr) of
          HsBndrWildCard XBndrWildCard GhcPs
_ ->
            -- See Note [Wildcard binders in disallowed contexts] in GHC.Hs.Type
            SrcSpan -> TcRnMessage -> TcRn ()
addErrAt (GenLocated SrcSpanAnnA (HsTyVarBndr () GhcPs) -> SrcSpan
forall a e. HasLoc a => GenLocated a e -> SrcSpan
getLocA LHsTyVarBndr () GhcPs
GenLocated SrcSpanAnnA (HsTyVarBndr () GhcPs)
tvbndr) (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
forall a b. (a -> b) -> a -> b
$
              Maybe Name -> BadAnonWildcardContext -> TcRnMessage
TcRnIllegalWildcardInType Maybe Name
forall a. Maybe a
Nothing BadAnonWildcardContext
WildcardBndrInTyFamResultVar
          HsBndrVar XBndrVar GhcPs
_ (L SrcSpanAnnN
_ RdrName
resName) ->
            Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (RdrName
resName RdrName -> LocalRdrEnv -> Bool
`elemLocalRdrEnv` LocalRdrEnv
rdr_env) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
            SrcSpan -> TcRnMessage -> TcRn ()
addErrAt (GenLocated SrcSpanAnnA (HsTyVarBndr () GhcPs) -> SrcSpan
forall a e. HasLoc a => GenLocated a e -> SrcSpan
getLocA LHsTyVarBndr () GhcPs
GenLocated SrcSpanAnnA (HsTyVarBndr () GhcPs)
tvbndr) (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
forall a b. (a -> b) -> a -> b
$
              IdP GhcPs -> TcRnMessage
TcRnShadowedTyVarNameInFamResult IdP GhcPs
RdrName
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', FreeVars -> (Name -> FreeVars) -> Maybe Name -> FreeVars
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FreeVars
emptyFVs Name -> FreeVars
unitFV (LHsTyVarBndr () GhcRn -> Maybe (IdP GhcRn)
forall flag (p :: Pass).
LHsTyVarBndr flag (GhcPass p) -> Maybe (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 (Maybe Name -> [Name]
forall a. Maybe a -> [a]
maybeToList (LHsTyVarBndr () GhcRn -> Maybe (IdP GhcRn)
forall flag (p :: Pass).
LHsTyVarBndr flag (GhcPass p) -> Maybe (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

   ; case hsLTyVarName resTv of { Maybe (IdP GhcRn)
Nothing -> () -> TcRn ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                                ; Just IdP GhcRn
resName -> do {

   ; let -- See Note [Renaming injectivity annotation]
         lhsValid :: Bool
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 :: Set Name
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.
   ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
noRnErrors Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
lhsValid) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
        SrcSpan -> TcRnMessage -> TcRn ()
addErrAt (GenLocated SrcSpanAnnN RdrName -> SrcSpan
forall a e. HasLoc a => GenLocated a e -> SrcSpan
getLocA LIdP GhcPs
GenLocated SrcSpanAnnN RdrName
injFrom) (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
forall a b. (a -> b) -> a -> b
$
          IdP GhcRn -> LIdP GhcPs -> TcRnMessage
TcRnIncorrectTyVarOnLhsOfInjCond IdP GhcRn
resName LIdP GhcPs
injFrom

   ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
noRnErrors Bool -> Bool -> Bool
&& Bool -> Bool
not (Set Name -> Bool
forall a. Set a -> Bool
Set.null Set Name
rhsValid)) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
      do { let errorVars :: [Name]
errorVars = Set Name -> [Name]
forall a. Set a -> [a]
Set.toList Set Name
rhsValid
         ; SrcSpan -> TcRnMessage -> TcRn ()
addErrAt (EpAnnCO -> SrcSpan
forall a. HasLoc a => a -> SrcSpan
locA EpAnnCO
srcSpan) (TcRnMessage -> TcRn ()) -> TcRnMessage -> TcRn ()
forall a b. (a -> b) -> a -> b
$
              [Name] -> TcRnMessage
TcRnUnknownTyVarsOnRhsOfInjCond [Name]
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)]
-> [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
[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 -> LIdP GhcPs
forall pass. FieldOcc pass -> LIdP pass
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 = ConLikeInfo -> Int -> [FieldLabel] -> ConInfo
mkConInfo ConLikeInfo
ConIsPatSyn (([RecordPatSynField GhcPs] -> Int)
-> HsConDetails (ZonkAny 1) (ZonkAny 0) [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 (ZonkAny 1) (ZonkAny 0) [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 = ConLikeInfo -> Int -> [FieldLabel] -> ConInfo
mkConInfo ConLikeInfo
ConIsPatSyn (([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

conDetailsArity :: (rec -> Arity) -> HsConDetails tyarg arg rec -> Arity
conDetailsArity :: forall rec tyarg arg.
(rec -> Int) -> HsConDetails tyarg arg rec -> Int
conDetailsArity rec -> Int
recToArity = \case
  PrefixCon [tyarg]
_ [arg]
args -> [arg] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [arg]
args
  RecCon rec
rec -> rec -> Int
recToArity rec
rec
  InfixCon arg
_ arg
_ -> Int
2

{-
*********************************************************
*                                                      *
\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 -> LHsBindsLR a a -> LHsBindsLR a a
forall a. [a] -> [a] -> [a]
++ [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"