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

Main pass of renamer
-}

{-# LANGUAGE CPP #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}

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

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

#include "HsVersions.h"

import GHC.Prelude

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.Env
import GHC.Rename.Utils ( HsDocContext(..), mapFvRn, bindLocalNames
                        , checkDupRdrNames, bindLocalNamesFV
                        , checkShadowedRdrNames, warnUnusedTypePatterns
                        , extendTyVarEnvFVRn, newLocalBndrsRn
                        , withHsDocContext, noNestedForallsContextsErr
                        , addNoNestedForallsContextsErr, checkInferredVars )
import GHC.Rename.Unbound ( mkUnboundName, notInScopeErr )
import GHC.Rename.Names
import GHC.Rename.Doc   ( rnHsDoc, rnMbLHsDoc )
import GHC.Tc.Gen.Annotation ( annCtxt )
import GHC.Tc.Utils.Monad

import GHC.Types.ForeignCall ( CCallTarget(..) )
import GHC.Unit.Module
import GHC.Driver.Types ( Warnings(..), plusWarns )
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.Types.Avail
import GHC.Utils.Outputable
import GHC.Data.Bag
import GHC.Types.Basic  ( pprRuleName, TypeOrKind(..) )
import GHC.Data.FastString
import GHC.Types.SrcLoc as SrcLoc
import GHC.Driver.Session
import GHC.Utils.Misc   ( debugIsOn, lengthExceeds, partitionWith )
import GHC.Driver.Types ( HscEnv, hsc_dflags )
import GHC.Data.List.SetOps ( findDupsEq, removeDups, equivClasses )
import GHC.Data.Graph.Directed ( SCC, flattenSCC, flattenSCCs, Node(..)
                               , stronglyConnCompFromEdgedVerticesUniq )
import GHC.Types.Unique.Set
import GHC.Data.OrdList
import qualified GHC.LanguageExtensions as LangExt

import Control.Monad
import Control.Arrow ( first )
import Data.List ( mapAccumL )
import qualified Data.List.NonEmpty as NE
import Data.List.NonEmpty ( NonEmpty(..) )
import Data.Maybe ( isNothing, isJust, fromMaybe, mapMaybe )
import qualified Data.Set as Set ( difference, fromList, toList, null )
import Data.Function ( on )

{- | @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]
hs_docs    = [LDocDecl]
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
   MiniFixityEnv
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
   --
   ((TcGblEnv, TcLclEnv)
tc_envs, FreeVars
tc_bndrs) <- MiniFixityEnv
-> HsGroup GhcPs -> RnM ((TcGblEnv, TcLclEnv), FreeVars)
getLocalNonValBinders MiniFixityEnv
local_fix_env HsGroup GhcPs
group ;


   (TcGblEnv, TcLclEnv)
-> RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn)
forall gbl' lcl' a gbl lcl.
(gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a
setEnvs (TcGblEnv, TcLclEnv)
tc_envs (RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn))
-> RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn)
forall a b. (a -> b) -> a -> b
$ do {

   TcRn ()
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)

   HsValBinds GhcPs
-> MiniFixityEnv
-> ([Name] -> RnM (TcGblEnv, HsGroup GhcRn))
-> RnM (TcGblEnv, HsGroup GhcRn)
forall a.
HsValBinds GhcPs
-> MiniFixityEnv
-> ([Name] -> TcRnIf TcGblEnv TcLclEnv a)
-> TcRnIf TcGblEnv TcLclEnv a
extendPatSynEnv HsValBinds GhcPs
val_decls MiniFixityEnv
local_fix_env (([Name] -> RnM (TcGblEnv, HsGroup GhcRn))
 -> RnM (TcGblEnv, HsGroup GhcRn))
-> ([Name] -> RnM (TcGblEnv, HsGroup GhcRn))
-> RnM (TcGblEnv, HsGroup GhcRn)
forall a b. (a -> b) -> a -> b
$ \[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.
   HsValBindsLR GhcRn GhcPs
new_lhs <- MiniFixityEnv -> HsValBinds GhcPs -> RnM (HsValBindsLR GhcRn GhcPs)
rnTopBindsLHS MiniFixityEnv
local_fix_env HsValBinds GhcPs
val_decls ;

   -- Bind the LHSes (and their fixities) in the global rdr environment
   let { id_bndrs :: [IdP GhcRn]
id_bndrs = HsValBindsLR GhcRn GhcPs -> [IdP GhcRn]
forall (idL :: Pass) (idR :: Pass).
CollectPass (GhcPass idL) =>
HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
collectHsIdBinders HsValBindsLR GhcRn GhcPs
new_lhs } ;  -- Excludes pattern-synonym binders
                                                    -- They are already in scope
   String -> SDoc -> TcRn ()
traceRn String
"rnSrcDecls" ([Name] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Name]
[IdP GhcRn]
id_bndrs) ;
   (TcGblEnv, TcLclEnv)
tc_envs <- [AvailInfo] -> MiniFixityEnv -> RnM (TcGblEnv, TcLclEnv)
extendGlobalRdrEnvRn ((Name -> AvailInfo) -> [Name] -> [AvailInfo]
forall a b. (a -> b) -> [a] -> [b]
map Name -> AvailInfo
avail [Name]
[IdP GhcRn]
id_bndrs) MiniFixityEnv
local_fix_env ;
   (TcGblEnv, TcLclEnv)
-> RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn)
forall gbl' lcl' a gbl lcl.
(gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a
setEnvs (TcGblEnv, TcLclEnv)
tc_envs (RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn))
-> RnM (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn)
forall a b. (a -> b) -> a -> b
$ 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.
   String -> SDoc -> TcRn ()
traceRn String
"Start rnTyClDecls" ([TyClGroup GhcPs] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TyClGroup GhcPs]
tycl_decls) ;
   ([TyClGroup GhcRn]
rn_tycl_decls, FreeVars
src_fvs1) <- [TyClGroup GhcPs] -> RnM ([TyClGroup GhcRn], FreeVars)
rnTyClDecls [TyClGroup GhcPs]
tycl_decls ;

   -- (F) Rename Value declarations right-hand sides
   String -> SDoc -> TcRn ()
traceRn String
"Start rnmono" SDoc
empty ;
   let { val_bndr_set :: FreeVars
val_bndr_set = [Name] -> FreeVars
mkNameSet [Name]
[IdP GhcRn]
id_bndrs FreeVars -> FreeVars -> FreeVars
`unionNameSet` [Name] -> FreeVars
mkNameSet [Name]
pat_syn_bndrs } ;
   Bool
is_boot <- TcRn Bool
tcIsHsBootOrSig ;
   (HsValBinds GhcRn
rn_val_decls, DefUses
bind_dus) <- if Bool
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 FreeVars
-> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
rnTopBindsBoot FreeVars
tc_bndrs HsValBindsLR GhcRn GhcPs
new_lhs
    else HsSigCtxt
-> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
rnValBindsRHS (FreeVars -> HsSigCtxt
TopSigCtxt FreeVars
val_bndr_set) HsValBindsLR GhcRn GhcPs
new_lhs ;
   String -> SDoc -> TcRn ()
traceRn String
"finish rnmono" (HsValBinds GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsValBinds GhcRn
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
all_bndrs = FreeVars
tc_bndrs FreeVars -> FreeVars -> FreeVars
`unionNameSet` FreeVars
val_bndr_set } ;
   [GenLocated SrcSpan (FixitySig GhcRn)]
rn_fix_decls <- (LFixitySig GhcPs
 -> IOEnv
      (Env TcGblEnv TcLclEnv) (GenLocated SrcSpan (FixitySig GhcRn)))
-> [LFixitySig GhcPs]
-> IOEnv
     (Env TcGblEnv TcLclEnv) [GenLocated SrcSpan (FixitySig GhcRn)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((FixitySig GhcPs
 -> IOEnv (Env TcGblEnv TcLclEnv) (FixitySig GhcRn))
-> LFixitySig GhcPs
-> IOEnv
     (Env TcGblEnv TcLclEnv) (GenLocated SrcSpan (FixitySig GhcRn))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (HsSigCtxt
-> FixitySig GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (FixitySig GhcRn)
rnSrcFixityDecl (FreeVars -> HsSigCtxt
TopSigCtxt FreeVars
all_bndrs)))
                        [LFixitySig GhcPs]
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
   Warnings
rn_warns <- FreeVars -> [LWarnDecls GhcPs] -> RnM Warnings
rnSrcWarnDecls FreeVars
all_bndrs [LWarnDecls GhcPs]
warn_decls ;

   -- (H) Rename Everything else

   ([Located (RuleDecls GhcRn)]
rn_rule_decls,    FreeVars
src_fvs2) <- Extension
-> TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
-> TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
forall gbl lcl a. Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
setXOptM Extension
LangExt.ScopedTypeVariables (TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
 -> TcRnIf
      TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars))
-> TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
-> TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
forall a b. (a -> b) -> a -> b
$
                                   (RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars))
-> [LRuleDecls GhcPs]
-> TcRnIf TcGblEnv TcLclEnv ([Located (RuleDecls GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars)
rnHsRuleDecls [LRuleDecls GhcPs]
rule_decls ;
                           -- Inside RULES, scoped type variables are on
   ([Located (ForeignDecl GhcRn)]
rn_foreign_decls, FreeVars
src_fvs3) <- (ForeignDecl GhcPs -> RnM (ForeignDecl GhcRn, FreeVars))
-> [LForeignDecl GhcPs]
-> RnM ([Located (ForeignDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList ForeignDecl GhcPs -> RnM (ForeignDecl GhcRn, FreeVars)
rnHsForeignDecl [LForeignDecl GhcPs]
foreign_decls ;
   ([Located (AnnDecl GhcRn)]
rn_ann_decls,     FreeVars
src_fvs4) <- (AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars))
-> [LAnnDecl GhcPs] -> RnM ([Located (AnnDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars)
rnAnnDecl       [LAnnDecl GhcPs]
ann_decls ;
   ([Located (DefaultDecl GhcRn)]
rn_default_decls, FreeVars
src_fvs5) <- (DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars))
-> [LDefaultDecl GhcPs]
-> RnM ([Located (DefaultDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars)
rnDefaultDecl   [LDefaultDecl GhcPs]
default_decls ;
   ([Located (DerivDecl GhcRn)]
rn_deriv_decls,   FreeVars
src_fvs6) <- (DerivDecl GhcPs -> RnM (DerivDecl GhcRn, FreeVars))
-> [LDerivDecl GhcPs]
-> RnM ([Located (DerivDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList DerivDecl GhcPs -> RnM (DerivDecl GhcRn, FreeVars)
rnSrcDerivDecl  [LDerivDecl GhcPs]
deriv_decls ;
   ([Located (SpliceDecl GhcRn)]
rn_splice_decls,  FreeVars
src_fvs7) <- (SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars))
-> [LSpliceDecl GhcPs]
-> RnM ([Located (SpliceDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars)
rnSpliceDecl    [LSpliceDecl GhcPs]
splice_decls ;
      -- Haddock docs; no free vars
   [LDocDecl]
rn_docs <- (LDocDecl -> IOEnv (Env TcGblEnv TcLclEnv) LDocDecl)
-> [LDocDecl] -> IOEnv (Env TcGblEnv TcLclEnv) [LDocDecl]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((DocDecl -> TcM DocDecl)
-> LDocDecl -> IOEnv (Env TcGblEnv TcLclEnv) LDocDecl
forall a b. (a -> TcM b) -> Located a -> TcM (Located b)
wrapLocM DocDecl -> TcM DocDecl
rnDocDecl) [LDocDecl]
docs ;

   TcGblEnv
last_tcg_env <- TcRnIf TcGblEnv TcLclEnv TcGblEnv
forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv ;
   -- (I) Compute the results and return
   let {rn_group :: HsGroup GhcRn
rn_group = HsGroup :: forall p.
XCHsGroup p
-> HsValBinds p
-> [LSpliceDecl p]
-> [TyClGroup p]
-> [LDerivDecl p]
-> [LFixitySig p]
-> [LDefaultDecl p]
-> [LForeignDecl p]
-> [LWarnDecls p]
-> [LAnnDecl p]
-> [LRuleDecls p]
-> [LDocDecl]
-> HsGroup p
HsGroup { hs_ext :: XCHsGroup GhcRn
hs_ext     = NoExtField
XCHsGroup GhcRn
noExtField,
                             hs_valds :: HsValBinds GhcRn
hs_valds   = HsValBinds GhcRn
rn_val_decls,
                             hs_splcds :: [Located (SpliceDecl GhcRn)]
hs_splcds  = [Located (SpliceDecl GhcRn)]
rn_splice_decls,
                             hs_tyclds :: [TyClGroup GhcRn]
hs_tyclds  = [TyClGroup GhcRn]
rn_tycl_decls,
                             hs_derivds :: [Located (DerivDecl GhcRn)]
hs_derivds = [Located (DerivDecl GhcRn)]
rn_deriv_decls,
                             hs_fixds :: [GenLocated SrcSpan (FixitySig GhcRn)]
hs_fixds   = [GenLocated SrcSpan (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 :: [Located (ForeignDecl GhcRn)]
hs_fords  = [Located (ForeignDecl GhcRn)]
rn_foreign_decls,
                             hs_annds :: [Located (AnnDecl GhcRn)]
hs_annds  = [Located (AnnDecl GhcRn)]
rn_ann_decls,
                             hs_defds :: [Located (DefaultDecl GhcRn)]
hs_defds  = [Located (DefaultDecl GhcRn)]
rn_default_decls,
                             hs_ruleds :: [Located (RuleDecls GhcRn)]
hs_ruleds = [Located (RuleDecls GhcRn)]
rn_rule_decls,
                             hs_docs :: [LDocDecl]
hs_docs   = [LDocDecl]
rn_docs } ;

        tcf_bndrs :: [Name]
tcf_bndrs = [TyClGroup GhcRn] -> [Located (ForeignDecl GhcRn)] -> [Name]
hsTyClForeignBinders [TyClGroup GhcRn]
rn_tycl_decls [Located (ForeignDecl GhcRn)]
rn_foreign_decls ;
        other_def :: (Maybe FreeVars, FreeVars)
other_def  = (FreeVars -> Maybe FreeVars
forall a. a -> Maybe a
Just ([Name] -> FreeVars
mkNameSet [Name]
tcf_bndrs), FreeVars
emptyNameSet) ;
        other_fvs :: FreeVars
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 :: DefUses
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 :: TcGblEnv
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 :: Warnings
tcg_warns = TcGblEnv -> Warnings
tcg_warns TcGblEnv
tcg_env' Warnings -> Warnings -> Warnings
`plusWarns` Warnings
rn_warns };
       } ;
   String -> SDoc -> TcRn ()
traceRn String
"finish rnSrc" (HsGroup GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsGroup GhcRn
rn_group) ;
   String -> SDoc -> TcRn ()
traceRn String
"finish Dus" (DefUses -> SDoc
forall a. Outputable a => a -> SDoc
ppr DefUses
src_dus ) ;
   (TcGblEnv, HsGroup GhcRn) -> RnM (TcGblEnv, HsGroup GhcRn)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcGblEnv
final_tcg_env, HsGroup GhcRn
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 :: DefUses
tcg_dus = TcGblEnv -> DefUses
tcg_dus TcGblEnv
tcg_env DefUses -> DefUses -> DefUses
`plusDU` DefUses
dus }

rnList :: (a -> RnM (b, FreeVars)) -> [Located a] -> RnM ([Located b], FreeVars)
rnList :: forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList a -> RnM (b, FreeVars)
f [Located a]
xs = (Located a -> RnM (Located b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
forall a b. (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
mapFvRn ((a -> RnM (b, FreeVars)) -> Located a -> RnM (Located b, FreeVars)
forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM a -> RnM (b, FreeVars)
f) [Located a]
xs

{-
*********************************************************
*                                                       *
        HsDoc stuff
*                                                       *
*********************************************************
-}

rnDocDecl :: DocDecl -> RnM DocDecl
rnDocDecl :: DocDecl -> TcM DocDecl
rnDocDecl (DocCommentNext HsDocString
doc) = do
  HsDocString
rn_doc <- HsDocString -> RnM HsDocString
rnHsDoc HsDocString
doc
  DocDecl -> TcM DocDecl
forall (m :: * -> *) a. Monad m => a -> m a
return (HsDocString -> DocDecl
DocCommentNext HsDocString
rn_doc)
rnDocDecl (DocCommentPrev HsDocString
doc) = do
  HsDocString
rn_doc <- HsDocString -> RnM HsDocString
rnHsDoc HsDocString
doc
  DocDecl -> TcM DocDecl
forall (m :: * -> *) a. Monad m => a -> m a
return (HsDocString -> DocDecl
DocCommentPrev HsDocString
rn_doc)
rnDocDecl (DocCommentNamed String
str HsDocString
doc) = do
  HsDocString
rn_doc <- HsDocString -> RnM HsDocString
rnHsDoc HsDocString
doc
  DocDecl -> TcM DocDecl
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> HsDocString -> DocDecl
DocCommentNamed String
str HsDocString
rn_doc)
rnDocDecl (DocGroup Int
lev HsDocString
doc) = do
  HsDocString
rn_doc <- HsDocString -> RnM HsDocString
rnHsDoc HsDocString
doc
  DocDecl -> TcM DocDecl
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> HsDocString -> DocDecl
DocGroup Int
lev HsDocString
rn_doc)

{-
*********************************************************
*                                                       *
        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 Warnings
rnSrcWarnDecls :: FreeVars -> [LWarnDecls GhcPs] -> RnM Warnings
rnSrcWarnDecls FreeVars
_ []
  = Warnings -> RnM Warnings
forall (m :: * -> *) a. Monad m => a -> m a
return Warnings
NoWarnings

rnSrcWarnDecls FreeVars
bndr_set [LWarnDecls GhcPs]
decls'
  = do { -- check for duplicates
       ; (NonEmpty (Located RdrName) -> TcRn ())
-> [NonEmpty (Located RdrName)] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ NonEmpty (Located RdrName)
dups -> let ((L SrcSpan
loc RdrName
rdr) :| (Located RdrName
lrdr':[Located RdrName]
_)) = NonEmpty (Located RdrName)
dups
                          in SrcSpan -> SDoc -> TcRn ()
addErrAt SrcSpan
loc (Located RdrName -> RdrName -> SDoc
dupWarnDecl Located RdrName
lrdr' RdrName
rdr))
               [NonEmpty (Located RdrName)]
warn_rdr_dups
       ; [[(OccName, WarningTxt)]]
pairs_s <- (Located (WarnDecl GhcPs)
 -> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)])
-> [Located (WarnDecl GhcPs)]
-> IOEnv (Env TcGblEnv TcLclEnv) [[(OccName, WarningTxt)]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((WarnDecl GhcPs
 -> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)])
-> Located (WarnDecl GhcPs)
-> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)]
forall a b. (a -> TcM b) -> Located a -> TcM b
addLocM WarnDecl GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)]
rn_deprec) [Located (WarnDecl GhcPs)]
decls
       ; Warnings -> RnM Warnings
forall (m :: * -> *) a. Monad m => a -> m a
return ([(OccName, WarningTxt)] -> Warnings
WarnSome (([[(OccName, WarningTxt)]] -> [(OccName, WarningTxt)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[(OccName, WarningTxt)]]
pairs_s))) }
 where
   decls :: [Located (WarnDecl GhcPs)]
decls = (LWarnDecls GhcPs -> [Located (WarnDecl GhcPs)])
-> [LWarnDecls GhcPs] -> [Located (WarnDecl GhcPs)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (WarnDecls GhcPs -> [Located (WarnDecl GhcPs)]
forall pass. WarnDecls pass -> [LWarnDecl pass]
wd_warnings (WarnDecls GhcPs -> [Located (WarnDecl GhcPs)])
-> (LWarnDecls GhcPs -> WarnDecls GhcPs)
-> LWarnDecls GhcPs
-> [Located (WarnDecl GhcPs)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LWarnDecls GhcPs -> WarnDecls GhcPs
forall l e. GenLocated l e -> e
unLoc) [LWarnDecls GhcPs]
decls'

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

   rn_deprec :: WarnDecl GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)]
rn_deprec (Warning XWarning GhcPs
_ [Located (IdP GhcPs)]
rdr_names WarningTxt
txt)
       -- ensures that the names are defined locally
     = do { [(RdrName, Name)]
names <- (Located RdrName
 -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)])
-> [Located RdrName]
-> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
forall (m :: * -> *) a b. Monad m => (a -> m [b]) -> [a] -> m [b]
concatMapM (HsSigCtxt
-> SDoc
-> RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
lookupLocalTcNames HsSigCtxt
sig_ctxt SDoc
what (RdrName -> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)])
-> (Located RdrName -> RdrName)
-> Located RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) [(RdrName, Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located RdrName -> RdrName
forall l e. GenLocated l e -> e
unLoc)
                                [Located RdrName]
[Located (IdP GhcPs)]
rdr_names
          ; [(OccName, WarningTxt)]
-> IOEnv (Env TcGblEnv TcLclEnv) [(OccName, WarningTxt)]
forall (m :: * -> *) a. Monad m => a -> m a
return [(RdrName -> OccName
rdrNameOcc RdrName
rdr, WarningTxt
txt) | (RdrName
rdr, Name
_) <- [(RdrName, Name)]
names] }

   what :: SDoc
what = String -> SDoc
text String
"deprecation"

   warn_rdr_dups :: [NonEmpty (Located RdrName)]
warn_rdr_dups = [Located RdrName] -> [NonEmpty (Located RdrName)]
findDupRdrNames
                   ([Located RdrName] -> [NonEmpty (Located RdrName)])
-> [Located RdrName] -> [NonEmpty (Located RdrName)]
forall a b. (a -> b) -> a -> b
$ (Located (WarnDecl GhcPs) -> [Located RdrName])
-> [Located (WarnDecl GhcPs)] -> [Located RdrName]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(L SrcSpan
_ (Warning XWarning GhcPs
_ [Located (IdP GhcPs)]
ns WarningTxt
_)) -> [Located RdrName]
[Located (IdP GhcPs)]
ns) [Located (WarnDecl GhcPs)]
decls

findDupRdrNames :: [Located RdrName] -> [NonEmpty (Located RdrName)]
findDupRdrNames :: [Located RdrName] -> [NonEmpty (Located RdrName)]
findDupRdrNames = (Located RdrName -> Located RdrName -> Bool)
-> [Located RdrName] -> [NonEmpty (Located RdrName)]
forall a. (a -> a -> Bool) -> [a] -> [NonEmpty a]
findDupsEq (\ Located RdrName
x -> \ Located RdrName
y -> RdrName -> OccName
rdrNameOcc (Located RdrName -> RdrName
forall l e. GenLocated l e -> e
unLoc Located RdrName
x) OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
== RdrName -> OccName
rdrNameOcc (Located RdrName -> RdrName
forall l e. GenLocated l e -> e
unLoc Located RdrName
y))

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

dupWarnDecl :: Located RdrName -> RdrName -> SDoc
-- Located RdrName -> DeprecDecl RdrName -> SDoc
dupWarnDecl :: Located RdrName -> RdrName -> SDoc
dupWarnDecl Located RdrName
d RdrName
rdr_name
  = [SDoc] -> SDoc
vcat [String -> SDoc
text String
"Multiple warning declarations for" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name),
          String -> SDoc
text String
"also at " SDoc -> SDoc -> SDoc
<+> SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Located RdrName -> SrcSpan
forall l e. GenLocated l e -> l
getLoc Located RdrName
d)]

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

rnAnnDecl :: AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars)
rnAnnDecl :: AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars)
rnAnnDecl ann :: AnnDecl GhcPs
ann@(HsAnnotation XHsAnnotation GhcPs
_ SourceText
s AnnProvenance (IdP GhcPs)
provenance Located (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 { (AnnProvenance Name
provenance', FreeVars
provenance_fvs) <- AnnProvenance RdrName -> RnM (AnnProvenance Name, FreeVars)
rnAnnProvenance AnnProvenance RdrName
AnnProvenance (IdP GhcPs)
provenance
       ; (LHsExpr GhcRn
expr', FreeVars
expr_fvs) <- ThStage
-> TcM (LHsExpr GhcRn, FreeVars) -> TcM (LHsExpr GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage (SpliceType -> ThStage
Splice SpliceType
Untyped) (TcM (LHsExpr GhcRn, FreeVars) -> TcM (LHsExpr GhcRn, FreeVars))
-> TcM (LHsExpr GhcRn, FreeVars) -> TcM (LHsExpr GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                              Located (HsExpr GhcPs) -> TcM (LHsExpr GhcRn, FreeVars)
rnLExpr Located (HsExpr GhcPs)
expr
       ; (AnnDecl GhcRn, FreeVars) -> RnM (AnnDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XHsAnnotation GhcRn
-> SourceText
-> AnnProvenance (IdP GhcRn)
-> LHsExpr GhcRn
-> AnnDecl GhcRn
forall pass.
XHsAnnotation pass
-> SourceText
-> AnnProvenance (IdP pass)
-> Located (HsExpr pass)
-> AnnDecl pass
HsAnnotation NoExtField
XHsAnnotation GhcRn
noExtField SourceText
s AnnProvenance Name
AnnProvenance (IdP GhcRn)
provenance' LHsExpr GhcRn
expr',
                 FreeVars
provenance_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
expr_fvs) }

rnAnnProvenance :: AnnProvenance RdrName
                -> RnM (AnnProvenance Name, FreeVars)
rnAnnProvenance :: AnnProvenance RdrName -> RnM (AnnProvenance Name, FreeVars)
rnAnnProvenance AnnProvenance RdrName
provenance = do
    AnnProvenance Name
provenance' <- (RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name)
-> AnnProvenance RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) (AnnProvenance Name)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name
lookupTopBndrRn AnnProvenance RdrName
provenance
    (AnnProvenance Name, FreeVars)
-> RnM (AnnProvenance Name, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnProvenance Name
provenance', FreeVars -> (Name -> FreeVars) -> Maybe Name -> FreeVars
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FreeVars
emptyFVs Name -> FreeVars
unitFV (AnnProvenance Name -> Maybe Name
forall name. AnnProvenance name -> Maybe name
annProvenanceName_maybe AnnProvenance Name
provenance'))

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

rnDefaultDecl :: DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars)
rnDefaultDecl :: DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars)
rnDefaultDecl (DefaultDecl XCDefaultDecl GhcPs
_ [LHsType GhcPs]
tys)
  = do { ([LHsType GhcRn]
tys', FreeVars
fvs) <- HsDocContext -> [LHsType GhcPs] -> RnM ([LHsType GhcRn], FreeVars)
rnLHsTypes HsDocContext
doc_str [LHsType GhcPs]
tys
       ; (DefaultDecl GhcRn, FreeVars) -> RnM (DefaultDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XCDefaultDecl GhcRn -> [LHsType GhcRn] -> DefaultDecl GhcRn
forall pass.
XCDefaultDecl pass -> [LHsType pass] -> DefaultDecl pass
DefaultDecl NoExtField
XCDefaultDecl GhcRn
noExtField [LHsType GhcRn]
tys', FreeVars
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 -> Located (IdP pass)
fd_name = Located (IdP GhcPs)
name, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
fd_sig_ty = LHsSigType GhcPs
ty, fd_fi :: forall pass. ForeignDecl pass -> ForeignImport
fd_fi = ForeignImport
spec })
  = do { HscEnv
topEnv :: HscEnv <- TcRnIf TcGblEnv TcLclEnv HscEnv
forall gbl lcl. TcRnIf gbl lcl HscEnv
getTopEnv
       ; Located Name
name' <- Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn Located RdrName
Located (IdP GhcPs)
name
       ; (LHsSigType GhcRn
ty', FreeVars
fvs) <- HsDocContext
-> TypeOrKind
-> LHsSigType GhcPs
-> RnM (LHsSigType GhcRn, FreeVars)
rnHsSigType (Located RdrName -> HsDocContext
ForeignDeclCtx Located RdrName
Located (IdP GhcPs)
name) TypeOrKind
TypeLevel LHsSigType GhcPs
ty

        -- Mark any PackageTarget style imports as coming from the current package
       ; let unitId :: Unit
unitId = DynFlags -> Unit
homeUnit (DynFlags -> Unit) -> DynFlags -> Unit
forall a b. (a -> b) -> a -> b
$ HscEnv -> DynFlags
hsc_dflags HscEnv
topEnv
             spec' :: ForeignImport
spec'  = Unit -> ForeignImport -> ForeignImport
patchForeignImport Unit
unitId ForeignImport
spec

       ; (ForeignDecl GhcRn, FreeVars) -> RnM (ForeignDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (ForeignImport :: forall pass.
XForeignImport pass
-> Located (IdP pass)
-> LHsSigType pass
-> ForeignImport
-> ForeignDecl pass
ForeignImport { fd_i_ext :: XForeignImport GhcRn
fd_i_ext = NoExtField
XForeignImport GhcRn
noExtField
                               , fd_name :: Located (IdP GhcRn)
fd_name = Located Name
Located (IdP GhcRn)
name', fd_sig_ty :: LHsSigType GhcRn
fd_sig_ty = LHsSigType GhcRn
ty'
                               , fd_fi :: ForeignImport
fd_fi = ForeignImport
spec' }, FreeVars
fvs) }

rnHsForeignDecl (ForeignExport { fd_name :: forall pass. ForeignDecl pass -> Located (IdP pass)
fd_name = Located (IdP GhcPs)
name, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
fd_sig_ty = LHsSigType GhcPs
ty, fd_fe :: forall pass. ForeignDecl pass -> ForeignExport
fd_fe = ForeignExport
spec })
  = do { Located Name
name' <- Located RdrName -> RnM (Located Name)
lookupLocatedOccRn Located RdrName
Located (IdP GhcPs)
name
       ; (LHsSigType GhcRn
ty', FreeVars
fvs) <- HsDocContext
-> TypeOrKind
-> LHsSigType GhcPs
-> RnM (LHsSigType GhcRn, FreeVars)
rnHsSigType (Located RdrName -> HsDocContext
ForeignDeclCtx Located RdrName
Located (IdP GhcPs)
name) TypeOrKind
TypeLevel LHsSigType GhcPs
ty
       ; (ForeignDecl GhcRn, FreeVars) -> RnM (ForeignDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (ForeignExport :: forall pass.
XForeignExport pass
-> Located (IdP pass)
-> LHsSigType pass
-> ForeignExport
-> ForeignDecl pass
ForeignExport { fd_e_ext :: XForeignExport GhcRn
fd_e_ext = NoExtField
XForeignExport GhcRn
noExtField
                               , fd_name :: Located (IdP GhcRn)
fd_name = Located Name
Located (IdP GhcRn)
name', fd_sig_ty :: LHsSigType GhcRn
fd_sig_ty = LHsSigType GhcRn
ty'
                               , fd_fe :: ForeignExport
fd_fe = ForeignExport
spec }
                , FreeVars
fvs FreeVars -> Name -> FreeVars
`addOneFV` Located Name -> Name
forall l e. GenLocated l e -> e
unLoc Located Name
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 -> ForeignImport
patchForeignImport :: Unit -> ForeignImport -> ForeignImport
patchForeignImport Unit
unit (CImport Located CCallConv
cconv Located Safety
safety Maybe Header
fs CImportSpec
spec Located SourceText
src)
        = Located CCallConv
-> Located Safety
-> Maybe Header
-> CImportSpec
-> Located SourceText
-> ForeignImport
CImport Located CCallConv
cconv Located Safety
safety Maybe Header
fs (Unit -> CImportSpec -> CImportSpec
patchCImportSpec Unit
unit CImportSpec
spec) Located SourceText
src

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 { (TyFamInstDecl GhcRn
tfi', FreeVars
fvs) <- AssocTyFamInfo
-> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
rnTyFamInstDecl (ClosedTyFamInfo -> AssocTyFamInfo
NonAssocTyFamEqn ClosedTyFamInfo
NotClosedTyFam) TyFamInstDecl GhcPs
tfi
       ; (InstDecl GhcRn, FreeVars) -> RnM (InstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (TyFamInstD :: forall pass.
XTyFamInstD pass -> TyFamInstDecl pass -> InstDecl pass
TyFamInstD { tfid_ext :: XTyFamInstD GhcRn
tfid_ext = NoExtField
XTyFamInstD GhcRn
noExtField, tfid_inst :: TyFamInstDecl GhcRn
tfid_inst = TyFamInstDecl GhcRn
tfi' }, FreeVars
fvs) }

rnSrcInstDecl (DataFamInstD { dfid_inst :: forall pass. InstDecl pass -> DataFamInstDecl pass
dfid_inst = DataFamInstDecl GhcPs
dfi })
  = do { (DataFamInstDecl GhcRn
dfi', FreeVars
fvs) <- AssocTyFamInfo
-> DataFamInstDecl GhcPs -> RnM (DataFamInstDecl GhcRn, FreeVars)
rnDataFamInstDecl (ClosedTyFamInfo -> AssocTyFamInfo
NonAssocTyFamEqn ClosedTyFamInfo
NotClosedTyFam) DataFamInstDecl GhcPs
dfi
       ; (InstDecl GhcRn, FreeVars) -> RnM (InstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (DataFamInstD :: forall pass.
XDataFamInstD pass -> DataFamInstDecl pass -> InstDecl pass
DataFamInstD { dfid_ext :: XDataFamInstD GhcRn
dfid_ext = NoExtField
XDataFamInstD GhcRn
noExtField, dfid_inst :: DataFamInstDecl GhcRn
dfid_inst = DataFamInstDecl GhcRn
dfi' }, FreeVars
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)
       ; (ClsInstDecl GhcRn
cid', FreeVars
fvs) <- ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
rnClsInstDecl ClsInstDecl GhcPs
cid
       ; String -> SDoc -> TcRn ()
traceRn String
"rnSrcIstDecl end }" SDoc
empty
       ; (InstDecl GhcRn, FreeVars) -> RnM (InstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (ClsInstD :: forall pass. XClsInstD pass -> ClsInstDecl pass -> InstDecl pass
ClsInstD { cid_d_ext :: XClsInstD GhcRn
cid_d_ext = NoExtField
XClsInstD GhcRn
noExtField, cid_inst :: ClsInstDecl GhcRn
cid_inst = ClsInstDecl GhcRn
cid' }, FreeVars
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 ()
checkCanonicalMonadInstances

    WarningFlag -> TcRn () -> TcRn ()
forall gbl lcl.
WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
whenWOptM WarningFlag
Opt_WarnNonCanonicalMonoidInstances
        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  = do
          [LHsBindLR GhcRn GhcRn]
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
mbinds) ((LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ())
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall a b. (a -> b) -> a -> b
$ \(L SrcSpan
loc HsBindLR GhcRn GhcRn
mbind) -> SrcSpan -> TcRn () -> TcRn ()
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ do
              case HsBindLR GhcRn GhcRn
mbind of
                  FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = L SrcSpan
_ IdP GhcRn
name
                          , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
mg }
                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod1
                            WarningFlag
Opt_WarnNonCanonicalMonadInstances String
"pure" String
"return"

                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod1
                            WarningFlag
Opt_WarnNonCanonicalMonadInstances String
"(*>)" String
"(>>)"

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

      | Name
cls Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
monadClassName  = do
          [LHsBindLR GhcRn GhcRn]
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
mbinds) ((LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ())
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall a b. (a -> b) -> a -> b
$ \(L SrcSpan
loc HsBindLR GhcRn GhcRn
mbind) -> SrcSpan -> TcRn () -> TcRn ()
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ do
              case HsBindLR GhcRn GhcRn
mbind of
                  FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = L SrcSpan
_ IdP GhcRn
name
                          , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
mg }
                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod2
                            WarningFlag
Opt_WarnNonCanonicalMonadInstances String
"return" String
"pure"

                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod2
                            WarningFlag
Opt_WarnNonCanonicalMonadInstances String
"(>>)" String
"(*>)"

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

      | Bool
otherwise = () -> TcRn ()
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  = do
          [LHsBindLR GhcRn GhcRn]
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
mbinds) ((LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ())
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall a b. (a -> b) -> a -> b
$ \(L SrcSpan
loc HsBindLR GhcRn GhcRn
mbind) -> SrcSpan -> TcRn () -> TcRn ()
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ do
              case HsBindLR GhcRn GhcRn
mbind of
                  FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id      = L SrcSpan
_ IdP GhcRn
name
                          , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
mg }
                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod1
                            WarningFlag
Opt_WarnNonCanonicalMonoidInstances String
"(<>)" String
"mappend"

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

      | Name
cls Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
monoidClassName  = do
          [LHsBindLR GhcRn GhcRn]
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
mbinds) ((LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ())
-> (LHsBindLR GhcRn GhcRn -> TcRn ()) -> TcRn ()
forall a b. (a -> b) -> a -> b
$ \(L SrcSpan
loc HsBindLR GhcRn GhcRn
mbind) -> SrcSpan -> TcRn () -> TcRn ()
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ do
              case HsBindLR GhcRn GhcRn
mbind of
                  FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = L SrcSpan
_ IdP GhcRn
name
                          , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
mg }
                      | Name
IdP GhcRn
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
                      -> WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod2NoDefault
                            WarningFlag
Opt_WarnNonCanonicalMonoidInstances String
"mappend" String
"(<>)"

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

      | Bool
otherwise = () -> TcRn ()
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 -> Located [LMatch p body]
mg_alts = (L SrcSpan
_ [L SrcSpan
_ (Match { m_pats :: forall p body. Match p body -> [LPat p]
m_pats = []
                                             , m_grhss :: forall p body. Match p body -> GRHSs p body
m_grhss = GRHSs GhcRn (LHsExpr GhcRn)
grhss })])}
        | GRHSs XCGRHSs GhcRn (LHsExpr GhcRn)
_ [L SrcSpan
_ (GRHS XCGRHS GhcRn (LHsExpr GhcRn)
_ [] LHsExpr GhcRn
body)] LHsLocalBinds GhcRn
lbinds <- GRHSs GhcRn (LHsExpr GhcRn)
grhss
        , EmptyLocalBinds XEmptyLocalBinds GhcRn GhcRn
_ <- LHsLocalBinds GhcRn -> HsLocalBindsLR GhcRn GhcRn
forall l e. GenLocated l e -> e
unLoc LHsLocalBinds GhcRn
lbinds
        , HsVar XVar GhcRn
_ Located (IdP GhcRn)
lrhsName  <- LHsExpr GhcRn -> HsExpr GhcRn
forall l e. GenLocated l e -> e
unLoc LHsExpr GhcRn
body  = Name -> Maybe Name
forall a. a -> Maybe a
Just (Located Name -> Name
forall l e. GenLocated l e -> e
unLoc Located Name
Located (IdP GhcRn)
lrhsName)
    isAliasMG MatchGroup GhcRn (LHsExpr GhcRn)
_ = Maybe Name
forall a. Maybe a
Nothing

    -- got "lhs = rhs" but expected something different
    addWarnNonCanonicalMethod1 :: WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod1 WarningFlag
flag String
lhs String
rhs = do
        WarnReason -> SDoc -> TcRn ()
addWarn (WarningFlag -> WarnReason
Reason WarningFlag
flag) (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
                       [ String -> SDoc
text String
"Noncanonical" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text (String
lhs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
rhs)) SDoc -> SDoc -> SDoc
<+>
                         String -> SDoc
text String
"definition detected"
                       , LHsSigType GhcRn -> SDoc
instDeclCtxt1 LHsSigType GhcRn
poly_ty
                       , String -> SDoc
text String
"Move definition from" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text String
rhs) SDoc -> SDoc -> SDoc
<+>
                         String -> SDoc
text String
"to" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (String -> SDoc
text String
lhs)
                       ]

    -- expected "lhs = rhs" but got something else
    addWarnNonCanonicalMethod2 :: WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod2 WarningFlag
flag String
lhs String
rhs = do
        WarnReason -> SDoc -> TcRn ()
addWarn (WarningFlag -> WarnReason
Reason WarningFlag
flag) (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
                       [ String -> SDoc
text String
"Noncanonical" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text String
lhs) SDoc -> SDoc -> SDoc
<+>
                         String -> SDoc
text String
"definition detected"
                       , LHsSigType GhcRn -> SDoc
instDeclCtxt1 LHsSigType GhcRn
poly_ty
                       , String -> SDoc
text String
"Either remove definition for" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text String
lhs) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"or define as" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text (String
lhs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
rhs))
                       ]

    -- like above, but method has no default impl
    addWarnNonCanonicalMethod2NoDefault :: WarningFlag -> String -> String -> TcRn ()
addWarnNonCanonicalMethod2NoDefault WarningFlag
flag String
lhs String
rhs = do
        WarnReason -> SDoc -> TcRn ()
addWarn (WarningFlag -> WarnReason
Reason WarningFlag
flag) (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
                       [ String -> SDoc
text String
"Noncanonical" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text String
lhs) SDoc -> SDoc -> SDoc
<+>
                         String -> SDoc
text String
"definition detected"
                       , LHsSigType GhcRn -> SDoc
instDeclCtxt1 LHsSigType GhcRn
poly_ty
                       , String -> SDoc
text String
"Define as" SDoc -> SDoc -> SDoc
<+>
                         SDoc -> SDoc
quotes (String -> SDoc
text (String
lhs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
rhs))
                       ]

    -- stolen from GHC.Tc.TyCl.Instance
    instDeclCtxt1 :: LHsSigType GhcRn -> SDoc
    instDeclCtxt1 :: LHsSigType GhcRn -> SDoc
instDeclCtxt1 LHsSigType GhcRn
hs_inst_ty
      = SDoc -> SDoc
inst_decl_ctxt (LHsType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr (LHsSigType GhcRn -> LHsType GhcRn
forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p)
getLHsInstDeclHead LHsSigType GhcRn
hs_inst_ty))

    inst_decl_ctxt :: SDoc -> SDoc
    inst_decl_ctxt :: SDoc -> SDoc
inst_decl_ctxt SDoc
doc = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"in the instance declaration for")
                         Int
2 (SDoc -> SDoc
quotes SDoc
doc SDoc -> SDoc -> SDoc
<> String -> SDoc
text String
".")


rnClsInstDecl :: ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
rnClsInstDecl :: ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars)
rnClsInstDecl (ClsInstDecl { 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 (Located OverlapMode)
cid_overlap_mode = Maybe (Located OverlapMode)
oflag
                           , cid_datafam_insts :: forall pass. ClsInstDecl pass -> [LDataFamInstDecl pass]
cid_datafam_insts = [LDataFamInstDecl GhcPs]
adts })
  = do { HsDocContext -> Maybe SDoc -> LHsSigType GhcPs -> TcRn ()
checkInferredVars HsDocContext
ctxt Maybe SDoc
inf_err LHsSigType GhcPs
inst_ty
       ; (LHsSigType GhcRn
inst_ty', FreeVars
inst_fvs) <- HsDocContext
-> TypeOrKind
-> LHsSigType GhcPs
-> RnM (LHsSigType GhcRn, FreeVars)
rnHsSigType HsDocContext
ctxt TypeOrKind
TypeLevel LHsSigType GhcPs
inst_ty
       ; let ([Name]
ktv_names, LHsContext GhcRn
_, LHsType GhcRn
head_ty') = LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn)
splitLHsInstDeclTy LHsSigType GhcRn
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 :: Maybe (SrcSpan, SDoc)
mb_nested_msg = SDoc -> LHsType GhcRn -> Maybe (SrcSpan, SDoc)
noNestedForallsContextsErr
                               (String -> SDoc
text String
"Instance head") LHsType GhcRn
head_ty'
             -- ...then check if the instance head is actually headed by a
             -- class type constructor...
             eith_cls :: Either (SrcSpan, SDoc) Name
eith_cls = case LHsType GhcRn -> Maybe (Located (IdP GhcRn))
forall (p :: Pass).
LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)))
hsTyGetAppHead_maybe LHsType GhcRn
head_ty' of
               Just (L SrcSpan
_ IdP GhcRn
cls) -> Name -> Either (SrcSpan, SDoc) Name
forall a b. b -> Either a b
Right Name
IdP GhcRn
cls
               Maybe (Located (IdP GhcRn))
Nothing        -> (SrcSpan, SDoc) -> Either (SrcSpan, SDoc) Name
forall a b. a -> Either a b
Left
                 ( LHsType GhcRn -> SrcSpan
forall l e. GenLocated l e -> l
getLoc LHsType GhcRn
head_ty'
                 , SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Illegal head of an instance declaration:"
                           SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (LHsType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsType GhcRn
head_ty'))
                      Int
2 ([SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Instance heads must be of the form"
                              , Int -> SDoc -> SDoc
nest Int
2 (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"C ty_1 ... ty_n"
                              , String -> SDoc
text String
"where" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Char -> SDoc
char Char
'C')
                                SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"is a class"
                              ])
                 )
         -- ...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.
       ; Name
cls <- case (Maybe (SrcSpan, SDoc)
mb_nested_msg, Either (SrcSpan, SDoc) Name
eith_cls) of
           (Maybe (SrcSpan, SDoc)
Nothing,   Right Name
cls) -> Name -> IOEnv (Env TcGblEnv TcLclEnv) Name
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
cls
           (Just (SrcSpan, SDoc)
err1, Either (SrcSpan, SDoc) Name
_)         -> (SrcSpan, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) Name
bail_out (SrcSpan, SDoc)
err1
           (Maybe (SrcSpan, SDoc)
_,         Left (SrcSpan, SDoc)
err2) -> (SrcSpan, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) Name
bail_out (SrcSpan, SDoc)
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
       ; (LHsBinds GhcRn
mbinds', [LSig GhcRn]
uprags', FreeVars
meth_fvs) <- Bool
-> Name
-> [Name]
-> LHsBinds GhcPs
-> [LSig GhcPs]
-> RnM (LHsBinds GhcRn, [LSig GhcRn], FreeVars)
rnMethodBinds Bool
False Name
cls [Name]
ktv_names LHsBinds GhcPs
mbinds [LSig GhcPs]
uprags

       ; Name -> LHsSigType GhcRn -> LHsBinds GhcRn -> TcRn ()
checkCanonicalInstances Name
cls LHsSigType GhcRn
inst_ty' LHsBinds GhcRn
mbinds'

       -- Rename the associated types, and type signatures
       -- Both need to have the instance type variables in scope
       ; String -> SDoc -> TcRn ()
traceRn String
"rnSrcInstDecl" (LHsSigType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigType GhcRn
inst_ty' SDoc -> SDoc -> SDoc
$$ [Name] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Name]
ktv_names)
       ; (([Located (TyFamInstDecl GhcRn)]
ats', [Located (DataFamInstDecl GhcRn)]
adts'), FreeVars
more_fvs)
             <- [Name]
-> RnM
     (([Located (TyFamInstDecl GhcRn)],
       [Located (DataFamInstDecl GhcRn)]),
      FreeVars)
-> RnM
     (([Located (TyFamInstDecl GhcRn)],
       [Located (DataFamInstDecl GhcRn)]),
      FreeVars)
forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
extendTyVarEnvFVRn [Name]
ktv_names (RnM
   (([Located (TyFamInstDecl GhcRn)],
     [Located (DataFamInstDecl GhcRn)]),
    FreeVars)
 -> RnM
      (([Located (TyFamInstDecl GhcRn)],
        [Located (DataFamInstDecl GhcRn)]),
       FreeVars))
-> RnM
     (([Located (TyFamInstDecl GhcRn)],
       [Located (DataFamInstDecl GhcRn)]),
      FreeVars)
-> RnM
     (([Located (TyFamInstDecl GhcRn)],
       [Located (DataFamInstDecl GhcRn)]),
      FreeVars)
forall a b. (a -> b) -> a -> b
$
                do { ([Located (TyFamInstDecl GhcRn)]
ats',  FreeVars
at_fvs)  <- (AssocTyFamInfo
 -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars))
-> Name
-> [Name]
-> [LTyFamInstDecl GhcPs]
-> RnM ([Located (TyFamInstDecl GhcRn)], FreeVars)
forall (decl :: * -> *).
(AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars))
-> Name
-> [Name]
-> [Located (decl GhcPs)]
-> RnM ([Located (decl GhcRn)], FreeVars)
rnATInstDecls AssocTyFamInfo
-> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
rnTyFamInstDecl Name
cls [Name]
ktv_names [LTyFamInstDecl GhcPs]
ats
                   ; ([Located (DataFamInstDecl GhcRn)]
adts', FreeVars
adt_fvs) <- (AssocTyFamInfo
 -> DataFamInstDecl GhcPs -> RnM (DataFamInstDecl GhcRn, FreeVars))
-> Name
-> [Name]
-> [LDataFamInstDecl GhcPs]
-> RnM ([Located (DataFamInstDecl GhcRn)], FreeVars)
forall (decl :: * -> *).
(AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars))
-> Name
-> [Name]
-> [Located (decl GhcPs)]
-> RnM ([Located (decl GhcRn)], FreeVars)
rnATInstDecls AssocTyFamInfo
-> DataFamInstDecl GhcPs -> RnM (DataFamInstDecl GhcRn, FreeVars)
rnDataFamInstDecl Name
cls [Name]
ktv_names [LDataFamInstDecl GhcPs]
adts
                   ; (([Located (TyFamInstDecl GhcRn)],
  [Located (DataFamInstDecl GhcRn)]),
 FreeVars)
-> RnM
     (([Located (TyFamInstDecl GhcRn)],
       [Located (DataFamInstDecl GhcRn)]),
      FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ( ([Located (TyFamInstDecl GhcRn)]
ats', [Located (DataFamInstDecl GhcRn)]
adts'), FreeVars
at_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
adt_fvs) }

       ; let all_fvs :: FreeVars
all_fvs = FreeVars
meth_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
more_fvs
                                FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
inst_fvs
       ; (ClsInstDecl GhcRn, FreeVars) -> RnM (ClsInstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (ClsInstDecl :: forall pass.
XCClsInstDecl pass
-> LHsSigType pass
-> LHsBinds pass
-> [LSig pass]
-> [LTyFamInstDecl pass]
-> [LDataFamInstDecl pass]
-> Maybe (Located OverlapMode)
-> ClsInstDecl pass
ClsInstDecl { cid_ext :: XCClsInstDecl GhcRn
cid_ext = NoExtField
XCClsInstDecl GhcRn
noExtField
                             , cid_poly_ty :: LHsSigType GhcRn
cid_poly_ty = LHsSigType GhcRn
inst_ty', cid_binds :: LHsBinds GhcRn
cid_binds = LHsBinds GhcRn
mbinds'
                             , cid_sigs :: [LSig GhcRn]
cid_sigs = [LSig GhcRn]
uprags', cid_tyfam_insts :: [Located (TyFamInstDecl GhcRn)]
cid_tyfam_insts = [Located (TyFamInstDecl GhcRn)]
ats'
                             , cid_overlap_mode :: Maybe (Located OverlapMode)
cid_overlap_mode = Maybe (Located OverlapMode)
oflag
                             , cid_datafam_insts :: [Located (DataFamInstDecl GhcRn)]
cid_datafam_insts = [Located (DataFamInstDecl GhcRn)]
adts' },
                 FreeVars
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
text String
"an instance declaration"
    inf_err :: Maybe SDoc
inf_err = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (String -> SDoc
text String
"Inferred type variables are not allowed")

    -- 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, SDoc) -> IOEnv (Env TcGblEnv TcLclEnv) Name
bail_out (SrcSpan
l, SDoc
err_msg) = do
      SrcSpan -> SDoc -> TcRn ()
addErrAt SrcSpan
l (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ HsDocContext -> SDoc -> SDoc
withHsDocContext HsDocContext
ctxt SDoc
err_msg
      Name -> IOEnv (Env TcGblEnv TcLclEnv) Name
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>"))

rnFamInstEqn :: HsDocContext
             -> AssocTyFamInfo
             -> FreeKiTyVars
             -- ^ Kind variables from the equation's RHS to be implicitly bound
             -- if no explicit forall.
             -> FamInstEqn GhcPs rhs
             -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
             -> RnM (FamInstEqn GhcRn rhs', FreeVars)
rnFamInstEqn :: forall rhs rhs'.
HsDocContext
-> AssocTyFamInfo
-> [Located RdrName]
-> FamInstEqn GhcPs rhs
-> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
rnFamInstEqn HsDocContext
doc AssocTyFamInfo
atfi [Located RdrName]
rhs_kvars
    (HsIB { hsib_body :: forall pass thing. HsImplicitBndrs pass thing -> thing
hsib_body = FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> Located (IdP pass)
feqn_tycon  = Located (IdP GhcPs)
tycon
                               , feqn_bndrs :: forall pass rhs. FamEqn pass rhs -> Maybe [LHsTyVarBndr () pass]
feqn_bndrs  = Maybe [LHsTyVarBndr () GhcPs]
mb_bndrs
                               , feqn_pats :: forall pass rhs. FamEqn pass rhs -> HsTyPats pass
feqn_pats   = HsTyPats 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 { Located Name
tycon' <- Maybe Name -> Located RdrName -> RnM (Located Name)
lookupFamInstName Maybe Name
mb_cls Located RdrName
Located (IdP GhcPs)
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.Rename.HsType), which means
         -- ignoring:
         --
         -- - pat_kity_vars_with_dups, the variables mentioned in the LHS of
         --   the equation, and
         -- - rhs_kvars, the kind variables mentioned in an outermost kind
         --   signature on the RHS of the equation. (See
         --   Note [Implicit quantification in type synonyms] in
         --   GHC.Rename.HsType for why these are implicitly quantified in the
         --   absence of an explicit forall).
         --
         -- For example:
         --
         -- @
         -- 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]
         -- @
       ; [Located RdrName]
all_imp_vars <- Bool -> [Located RdrName] -> RnM [Located RdrName]
forAllOrNothing (Maybe [LHsTyVarBndr () GhcPs] -> Bool
forall a. Maybe a -> Bool
isJust Maybe [LHsTyVarBndr () GhcPs]
mb_bndrs) ([Located RdrName] -> RnM [Located RdrName])
-> [Located RdrName] -> RnM [Located RdrName]
forall a b. (a -> b) -> a -> b
$
           -- No need to filter out explicit binders (the 'mb_bndrs = Just
           -- explicit_bndrs' case) because there must be none if we're going
           -- to implicitly bind anything, per the previous comment.
           [Located RdrName]
pat_kity_vars_with_dups [Located RdrName] -> [Located RdrName] -> [Located RdrName]
forall a. [a] -> [a] -> [a]
++ [Located RdrName]
rhs_kvars

       ; Maybe Name
-> [Located RdrName]
-> ([Name] -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
forall assoc a.
Maybe assoc
-> [Located RdrName]
-> ([Name] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnImplicitBndrs Maybe Name
mb_cls [Located RdrName]
all_imp_vars (([Name] -> RnM (FamInstEqn GhcRn rhs', FreeVars))
 -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> ([Name] -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
forall a b. (a -> b) -> a -> b
$ \[Name]
all_imp_var_names' ->
         HsDocContext
-> WarnUnusedForalls
-> Maybe Any
-> [LHsTyVarBndr () GhcPs]
-> ([LHsTyVarBndr () GhcRn]
    -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
forall flag a b.
OutputableBndrFlag flag =>
HsDocContext
-> WarnUnusedForalls
-> Maybe a
-> [LHsTyVarBndr flag GhcPs]
-> ([LHsTyVarBndr flag GhcRn] -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindLHsTyVarBndrs HsDocContext
doc WarnUnusedForalls
WarnUnusedForalls
                           Maybe Any
forall a. Maybe a
Nothing ([LHsTyVarBndr () GhcPs]
-> Maybe [LHsTyVarBndr () GhcPs] -> [LHsTyVarBndr () GhcPs]
forall a. a -> Maybe a -> a
fromMaybe [] Maybe [LHsTyVarBndr () GhcPs]
mb_bndrs) (([LHsTyVarBndr () GhcRn] -> RnM (FamInstEqn GhcRn rhs', FreeVars))
 -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> ([LHsTyVarBndr () GhcRn]
    -> RnM (FamInstEqn GhcRn rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
forall a b. (a -> b) -> a -> b
$ \[LHsTyVarBndr () GhcRn]
bndrs' ->
         -- Note: If we pass mb_cls instead of Nothing here,
         --  bindLHsTyVarBndrs will use class variables for any names
         --  the user meant to bring in scope here. This is an explicit
         --  forall, so we want fresh names, not class variables.
         --  Thus: always pass Nothing
    do { ([LHsTypeArg GhcRn]
pats', FreeVars
pat_fvs) <- HsDocContext
-> HsTyPats GhcPs -> RnM ([LHsTypeArg GhcRn], FreeVars)
rnLHsTypeArgs (Located RdrName -> HsDocContext
FamPatCtx Located RdrName
Located (IdP GhcPs)
tycon) HsTyPats GhcPs
pats
       ; (rhs'
payload', FreeVars
rhs_fvs) <- HsDocContext -> rhs -> RnM (rhs', FreeVars)
rn_payload HsDocContext
doc rhs
payload

          -- Report unused binders on the LHS
          -- See Note [Unused type variables in family instances]
       ; let -- The SrcSpan that rnImplicitBndrs will attach to each Name 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.
             all_imp_var_names :: [Name]
all_imp_var_names = (Name -> Name) -> [Name] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map (Name -> SrcSpan -> Name
`setNameLoc` SrcSpan
lhs_loc) [Name]
all_imp_var_names'

             groups :: [NonEmpty (Located RdrName)]
             groups :: [NonEmpty (Located RdrName)]
groups = (Located RdrName -> Located RdrName -> Ordering)
-> [Located RdrName] -> [NonEmpty (Located RdrName)]
forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
equivClasses Located RdrName -> Located RdrName -> Ordering
forall a l. Ord a => GenLocated l a -> GenLocated l a -> Ordering
cmpLocated ([Located RdrName] -> [NonEmpty (Located RdrName)])
-> [Located RdrName] -> [NonEmpty (Located RdrName)]
forall a b. (a -> b) -> a -> b
$
                      [Located RdrName]
pat_kity_vars_with_dups
       ; [Name]
nms_dups <- (Located RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name)
-> [Located RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) [Name]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name
lookupOccRn (RdrName -> IOEnv (Env TcGblEnv TcLclEnv) Name)
-> (Located RdrName -> RdrName)
-> Located RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located RdrName -> RdrName
forall l e. GenLocated l e -> e
unLoc) ([Located RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) [Name])
-> [Located RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) [Name]
forall a b. (a -> b) -> a -> b
$
                        [ Located RdrName
tv | (Located RdrName
tv :| (Located RdrName
_:[Located RdrName]
_)) <- [NonEmpty (Located RdrName)]
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
nms_used = FreeVars -> [Name] -> FreeVars
extendNameSetList FreeVars
rhs_fvs ([Name] -> FreeVars) -> [Name] -> FreeVars
forall a b. (a -> b) -> a -> b
$
                           [Name]
inst_tvs [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ [Name]
nms_dups
             all_nms :: [Name]
all_nms = [Name]
all_imp_var_names [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ [LHsTyVarBndr () GhcRn] -> [IdP GhcRn]
forall flag (p :: Pass).
[LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]
hsLTyVarNames [LHsTyVarBndr () GhcRn]
bndrs'
       ; [Name] -> FreeVars -> TcRn ()
warnUnusedTypePatterns [Name]
all_nms FreeVars
nms_used

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

       ; (FamInstEqn GhcRn rhs', FreeVars)
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (HsIB :: forall pass thing.
XHsIB pass thing -> thing -> HsImplicitBndrs pass thing
HsIB { hsib_ext :: XHsIB GhcRn (FamEqn GhcRn rhs')
hsib_ext = [Name]
XHsIB GhcRn (FamEqn GhcRn rhs')
all_imp_var_names -- Note [Wildcards in family instances]
                      , hsib_body :: FamEqn GhcRn rhs'
hsib_body
                          = FamEqn :: forall pass rhs.
XCFamEqn pass rhs
-> Located (IdP pass)
-> Maybe [LHsTyVarBndr () pass]
-> HsTyPats pass
-> LexicalFixity
-> rhs
-> FamEqn pass rhs
FamEqn { feqn_ext :: XCFamEqn GhcRn rhs'
feqn_ext    = NoExtField
XCFamEqn GhcRn rhs'
noExtField
                                   , feqn_tycon :: Located (IdP GhcRn)
feqn_tycon  = Located Name
Located (IdP GhcRn)
tycon'
                                   , feqn_bndrs :: Maybe [LHsTyVarBndr () GhcRn]
feqn_bndrs  = [LHsTyVarBndr () GhcRn]
bndrs' [LHsTyVarBndr () GhcRn]
-> Maybe [LHsTyVarBndr () GhcPs] -> Maybe [LHsTyVarBndr () GhcRn]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Maybe [LHsTyVarBndr () GhcPs]
mb_bndrs
                                   , feqn_pats :: [LHsTypeArg GhcRn]
feqn_pats   = [LHsTypeArg GhcRn]
pats'
                                   , feqn_fixity :: LexicalFixity
feqn_fixity = LexicalFixity
fixity
                                   , feqn_rhs :: rhs'
feqn_rhs    = rhs'
payload' } },
                 FreeVars
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_tvs :: [Name]
inst_tvs = case AssocTyFamInfo
atfi of
      NonAssocTyFamEqn ClosedTyFamInfo
_        -> []
      AssocTyFamDeflt Name
_         -> []
      AssocTyFamInst Name
_ [Name]
inst_tvs -> [Name]
inst_tvs

    pat_kity_vars_with_dups :: [Located RdrName]
pat_kity_vars_with_dups = HsTyPats GhcPs -> [Located RdrName]
extractHsTyArgRdrKiTyVars HsTyPats 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 (LHsTypeArg GhcPs -> SrcSpan) -> HsTyPats GhcPs -> [SrcSpan]
forall a b. (a -> b) -> [a] -> [b]
map LHsTypeArg GhcPs -> SrcSpan
forall pass. LHsTypeArg pass -> SrcSpan
lhsTypeArgSrcSpan HsTyPats GhcPs
pats [SrcSpan] -> [SrcSpan] -> [SrcSpan]
forall a. [a] -> [a] -> [a]
++ (Located RdrName -> SrcSpan) -> [Located RdrName] -> [SrcSpan]
forall a b. (a -> b) -> [a] -> [b]
map Located RdrName -> SrcSpan
forall l e. GenLocated l e -> l
getLoc [Located RdrName]
rhs_kvars of
      []         -> String -> SrcSpan
forall a. String -> a
panic String
"rnFamInstEqn.lhs_loc"
      [SrcSpan
loc]      -> SrcSpan
loc
      (SrcSpan
loc:[SrcSpan]
locs) -> SrcSpan
loc SrcSpan -> SrcSpan -> SrcSpan
`combineSrcSpans` [SrcSpan] -> SrcSpan
forall a. [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_eqn :: forall pass. TyFamInstDecl pass -> TyFamInstEqn pass
tfid_eqn = TyFamInstEqn GhcPs
eqn })
  = do { (TyFamInstEqn GhcRn
eqn', FreeVars
fvs) <- AssocTyFamInfo
-> TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars)
rnTyFamInstEqn AssocTyFamInfo
atfi TyFamInstEqn GhcPs
eqn
       ; (TyFamInstDecl GhcRn, FreeVars)
-> RnM (TyFamInstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (TyFamInstDecl :: forall pass. TyFamInstEqn pass -> TyFamInstDecl pass
TyFamInstDecl { tfid_eqn :: TyFamInstEqn GhcRn
tfid_eqn = TyFamInstEqn GhcRn
eqn' }, FreeVars
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@(HsIB { hsib_body :: forall pass thing. HsImplicitBndrs pass thing -> thing
hsib_body = FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> Located (IdP pass)
feqn_tycon = Located (IdP GhcPs)
tycon
                                   , feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
feqn_rhs   = LHsType GhcPs
rhs }})
  = HsDocContext
-> AssocTyFamInfo
-> [Located RdrName]
-> TyFamInstEqn GhcPs
-> (HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars))
-> RnM (TyFamInstEqn GhcRn, FreeVars)
forall rhs rhs'.
HsDocContext
-> AssocTyFamInfo
-> [Located RdrName]
-> FamInstEqn GhcPs rhs
-> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
rnFamInstEqn (Located RdrName -> HsDocContext
TySynCtx Located RdrName
Located (IdP GhcPs)
tycon) AssocTyFamInfo
atfi [Located RdrName]
rhs_kvs TyFamInstEqn GhcPs
eqn HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
rnTySyn
  where
    rhs_kvs :: [Located RdrName]
rhs_kvs = LHsType GhcPs -> [Located RdrName]
extractHsTyRdrTyVarsKindVars LHsType GhcPs
rhs

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 -> FamInstEqn pass (HsDataDefn pass)
dfid_eqn = eqn :: FamInstEqn GhcPs (HsDataDefn GhcPs)
eqn@(HsIB { hsib_body :: forall pass thing. HsImplicitBndrs pass thing -> thing
hsib_body =
                         FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> Located (IdP pass)
feqn_tycon = Located (IdP GhcPs)
tycon
                                , feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
feqn_rhs   = HsDataDefn GhcPs
rhs }})})
  = do { let rhs_kvs :: [Located RdrName]
rhs_kvs = HsDataDefn GhcPs -> [Located RdrName]
extractDataDefnKindVars HsDataDefn GhcPs
rhs
       ; (FamInstEqn GhcRn (HsDataDefn GhcRn)
eqn', FreeVars
fvs) <-
           HsDocContext
-> AssocTyFamInfo
-> [Located RdrName]
-> FamInstEqn GhcPs (HsDataDefn GhcPs)
-> (HsDocContext
    -> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars))
-> RnM (FamInstEqn GhcRn (HsDataDefn GhcRn), FreeVars)
forall rhs rhs'.
HsDocContext
-> AssocTyFamInfo
-> [Located RdrName]
-> FamInstEqn GhcPs rhs
-> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
-> RnM (FamInstEqn GhcRn rhs', FreeVars)
rnFamInstEqn (Located RdrName -> HsDocContext
TyDataCtx Located RdrName
Located (IdP GhcPs)
tycon) AssocTyFamInfo
atfi [Located RdrName]
rhs_kvs FamInstEqn GhcPs (HsDataDefn GhcPs)
eqn HsDocContext
-> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars)
rnDataDefn
       ; (DataFamInstDecl GhcRn, FreeVars)
-> RnM (DataFamInstDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (DataFamInstDecl :: forall pass.
FamInstEqn pass (HsDataDefn pass) -> DataFamInstDecl pass
DataFamInstDecl { dfid_eqn :: FamInstEqn GhcRn (HsDataDefn GhcRn)
dfid_eqn = FamInstEqn GhcRn (HsDataDefn GhcRn)
eqn' }, FreeVars
fvs) }

-- Renaming of the associated types in instances.

-- Rename associated type family decl in class
rnATDecls :: Name      -- Class
          -> [LFamilyDecl GhcPs]
          -> RnM ([LFamilyDecl GhcRn], FreeVars)
rnATDecls :: Name -> [LFamilyDecl GhcPs] -> RnM ([LFamilyDecl GhcRn], FreeVars)
rnATDecls Name
cls [LFamilyDecl GhcPs]
at_decls
  = (FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars))
-> [LFamilyDecl GhcPs] -> RnM ([LFamilyDecl GhcRn], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList (Maybe Name -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
rnFamDecl (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
cls)) [LFamilyDecl GhcPs]
at_decls

rnATInstDecls :: (AssocTyFamInfo ->           -- The function that renames
                  decl GhcPs ->               -- an instance. rnTyFamInstDecl
                  RnM (decl GhcRn, FreeVars)) -- or rnDataFamInstDecl
              -> Name      -- Class
              -> [Name]
              -> [Located (decl GhcPs)]
              -> RnM ([Located (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]
-> [Located (decl GhcPs)]
-> RnM ([Located (decl GhcRn)], FreeVars)
rnATInstDecls AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars)
rnFun Name
cls [Name]
tv_ns [Located (decl GhcPs)]
at_insts
  = (decl GhcPs -> RnM (decl GhcRn, FreeVars))
-> [Located (decl GhcPs)] -> RnM ([Located (decl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList (AssocTyFamInfo -> decl GhcPs -> RnM (decl GhcRn, FreeVars)
rnFun (Name -> [Name] -> AssocTyFamInfo
AssocTyFamInst Name
cls [Name]
tv_ns)) [Located (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]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Check that the RHS of the decl mentions only type variables that are explicitly
bound on the LHS.  For example, this is not ok
   class C a b where
      type F a x :: *
   instance C (p,q) r where
      type F (p,q) x = (x, r)   -- BAD: mentions 'r'
c.f. #5515

Kind variables, on the other hand, are allowed to be implicitly or explicitly
bound. As examples, this (#9574) is acceptable:
   class Funct f where
      type Codomain f :: *
   instance Funct ('KProxy :: KProxy o) where
      -- o is implicitly bound by the kind signature
      -- of the LHS type pattern ('KProxy)
      type Codomain 'KProxy = NatTr (Proxy :: o -> *)
And this (#14131) is also acceptable:
    data family Nat :: k -> k -> *
    -- k is implicitly bound by an invisible kind pattern
    newtype instance Nat :: (k -> *) -> (k -> *) -> * where
      Nat :: (forall xx. f xx -> g xx) -> Nat f g
We could choose to disallow this, but then associated type families would not
be able to be as expressive as top-level type synonyms. For example, this type
synonym definition is allowed:
    type T = (Nothing :: Maybe a)
So for parity with type synonyms, we also allow:
    type family   T :: Maybe a
    type instance T = (Nothing :: Maybe a)

All this applies only for *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 C a where
     type T a b
   instance C (Maybe a) where
     type forall b. T (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 C (Maybe a)` part. (see #16116).

In each case, the function which detects improperly bound variables on the RHS
is GHC.Tc.Validity.checkValidFamPats.

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 rnFamInstEqn 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 XCDerivDecl GhcPs
_ LHsSigWcType GhcPs
ty Maybe (LDerivStrategy GhcPs)
mds Maybe (Located OverlapMode)
overlap)
  = do { Bool
standalone_deriv_ok <- Extension -> TcRn Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.StandaloneDeriving
       ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
standalone_deriv_ok (SDoc -> TcRn ()
addErr SDoc
standaloneDerivErr)
       ; HsDocContext -> Maybe SDoc -> LHsSigType GhcPs -> TcRn ()
checkInferredVars HsDocContext
ctxt Maybe SDoc
inf_err LHsSigType GhcPs
nowc_ty
       ; (Maybe (LDerivStrategy GhcRn)
mds', LHsSigWcType GhcRn
ty', FreeVars
fvs) <- HsDocContext
-> Maybe (LDerivStrategy GhcPs)
-> RnM (LHsSigWcType GhcRn, FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), LHsSigWcType GhcRn, FreeVars)
forall a.
HsDocContext
-> Maybe (LDerivStrategy GhcPs)
-> RnM (a, FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
rnLDerivStrategy HsDocContext
ctxt Maybe (LDerivStrategy GhcPs)
mds (RnM (LHsSigWcType GhcRn, FreeVars)
 -> RnM
      (Maybe (LDerivStrategy GhcRn), LHsSigWcType GhcRn, FreeVars))
-> RnM (LHsSigWcType GhcRn, FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), LHsSigWcType GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$ HsDocContext
-> LHsSigWcType GhcPs -> RnM (LHsSigWcType GhcRn, FreeVars)
rnHsSigWcType HsDocContext
ctxt LHsSigWcType GhcPs
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).
       ; HsDocContext -> SDoc -> LHsType GhcRn -> TcRn ()
addNoNestedForallsContextsErr HsDocContext
ctxt
           (String -> SDoc
text String
"Standalone-derived instance head")
           (LHsSigType GhcRn -> LHsType GhcRn
forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p)
getLHsInstDeclHead (LHsSigType GhcRn -> LHsType GhcRn)
-> LHsSigType GhcRn -> LHsType GhcRn
forall a b. (a -> b) -> a -> b
$ LHsSigWcType GhcRn -> LHsSigType GhcRn
forall pass. LHsSigWcType pass -> LHsSigType pass
dropWildCards LHsSigWcType GhcRn
ty')
       ; Maybe (LDerivStrategy GhcRn) -> SrcSpan -> TcRn ()
warnNoDerivStrat Maybe (LDerivStrategy GhcRn)
mds' SrcSpan
loc
       ; (DerivDecl GhcRn, FreeVars) -> RnM (DerivDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XCDerivDecl GhcRn
-> LHsSigWcType GhcRn
-> Maybe (LDerivStrategy GhcRn)
-> Maybe (Located OverlapMode)
-> DerivDecl GhcRn
forall pass.
XCDerivDecl pass
-> LHsSigWcType pass
-> Maybe (LDerivStrategy pass)
-> Maybe (Located OverlapMode)
-> DerivDecl pass
DerivDecl NoExtField
XCDerivDecl GhcRn
noExtField LHsSigWcType GhcRn
ty' Maybe (LDerivStrategy GhcRn)
mds' Maybe (Located OverlapMode)
overlap, FreeVars
fvs) }
  where
    ctxt :: HsDocContext
ctxt    = HsDocContext
DerivDeclCtx
    inf_err :: Maybe SDoc
inf_err = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (String -> SDoc
text String
"Inferred type variables are not allowed")
    loc :: SrcSpan
loc = LHsType GhcPs -> SrcSpan
forall l e. GenLocated l e -> l
getLoc (LHsType GhcPs -> SrcSpan) -> LHsType GhcPs -> SrcSpan
forall a b. (a -> b) -> a -> b
$ LHsSigType GhcPs -> LHsType GhcPs
forall pass thing. HsImplicitBndrs pass thing -> thing
hsib_body LHsSigType GhcPs
nowc_ty
    nowc_ty :: LHsSigType GhcPs
nowc_ty = LHsSigWcType GhcPs -> LHsSigType GhcPs
forall pass. LHsSigWcType pass -> LHsSigType pass
dropWildCards LHsSigWcType GhcPs
ty

standaloneDerivErr :: SDoc
standaloneDerivErr :: SDoc
standaloneDerivErr
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Illegal standalone deriving declaration")
       Int
2 (String -> SDoc
text String
"Use StandaloneDeriving to enable this extension")

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

rnHsRuleDecls :: RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars)
rnHsRuleDecls :: RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars)
rnHsRuleDecls (HsRules { rds_src :: forall pass. RuleDecls pass -> SourceText
rds_src = SourceText
src
                       , rds_rules :: forall pass. RuleDecls pass -> [LRuleDecl pass]
rds_rules = [LRuleDecl GhcPs]
rules })
  = do { ([Located (RuleDecl GhcRn)]
rn_rules,FreeVars
fvs) <- (RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars))
-> [LRuleDecl GhcPs] -> RnM ([Located (RuleDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
rnHsRuleDecl [LRuleDecl GhcPs]
rules
       ; (RuleDecls GhcRn, FreeVars) -> RnM (RuleDecls GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (HsRules :: forall pass.
XCRuleDecls pass
-> SourceText -> [LRuleDecl pass] -> RuleDecls pass
HsRules { rds_ext :: XCRuleDecls GhcRn
rds_ext = NoExtField
XCRuleDecls GhcRn
noExtField
                         , rds_src :: SourceText
rds_src = SourceText
src
                         , rds_rules :: [Located (RuleDecl GhcRn)]
rds_rules = [Located (RuleDecl GhcRn)]
rn_rules }, FreeVars
fvs) }

rnHsRuleDecl :: RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
rnHsRuleDecl :: RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars)
rnHsRuleDecl (HsRule { rd_name :: forall pass. RuleDecl pass -> Located (SourceText, CLabelString)
rd_name = Located (SourceText, 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 -> Located (HsExpr pass)
rd_lhs  = Located (HsExpr GhcPs)
lhs
                     , rd_rhs :: forall pass. RuleDecl pass -> Located (HsExpr pass)
rd_rhs  = Located (HsExpr GhcPs)
rhs })
  = do { let rdr_names_w_loc :: [Located RdrName]
rdr_names_w_loc = (LRuleBndr GhcPs -> Located RdrName)
-> [LRuleBndr GhcPs] -> [Located RdrName]
forall a b. (a -> b) -> [a] -> [b]
map (RuleBndr GhcPs -> Located RdrName
get_var (RuleBndr GhcPs -> Located RdrName)
-> (LRuleBndr GhcPs -> RuleBndr GhcPs)
-> LRuleBndr GhcPs
-> Located RdrName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LRuleBndr GhcPs -> RuleBndr GhcPs
forall l e. GenLocated l e -> e
unLoc) [LRuleBndr GhcPs]
tmvs
       ; [Located RdrName] -> TcRn ()
checkDupRdrNames [Located RdrName]
rdr_names_w_loc
       ; [Located RdrName] -> TcRn ()
checkShadowedRdrNames [Located RdrName]
rdr_names_w_loc
       ; [Name]
names <- [Located RdrName] -> IOEnv (Env TcGblEnv TcLclEnv) [Name]
newLocalBndrsRn [Located RdrName]
rdr_names_w_loc
       ; let doc :: HsDocContext
doc = CLabelString -> HsDocContext
RuleCtx ((SourceText, CLabelString) -> CLabelString
forall a b. (a, b) -> b
snd ((SourceText, CLabelString) -> CLabelString)
-> (SourceText, CLabelString) -> CLabelString
forall a b. (a -> b) -> a -> b
$ Located (SourceText, CLabelString) -> (SourceText, CLabelString)
forall l e. GenLocated l e -> e
unLoc Located (SourceText, CLabelString)
rule_name)
       ; HsDocContext
-> Maybe [LHsTyVarBndr () GhcPs]
-> (Maybe [LHsTyVarBndr () GhcRn]
    -> RnM (RuleDecl GhcRn, FreeVars))
-> RnM (RuleDecl GhcRn, FreeVars)
forall b.
HsDocContext
-> Maybe [LHsTyVarBndr () GhcPs]
-> (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindRuleTyVars HsDocContext
doc Maybe [LHsTyVarBndr () GhcPs]
Maybe [LHsTyVarBndr () (NoGhcTc GhcPs)]
tyvs ((Maybe [LHsTyVarBndr () GhcRn] -> RnM (RuleDecl GhcRn, FreeVars))
 -> RnM (RuleDecl GhcRn, FreeVars))
-> (Maybe [LHsTyVarBndr () GhcRn]
    -> RnM (RuleDecl GhcRn, FreeVars))
-> RnM (RuleDecl GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ Maybe [LHsTyVarBndr () GhcRn]
tyvs' ->
         HsDocContext
-> Maybe [LHsTyVarBndr () 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]
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 { (LHsExpr GhcRn
lhs', FreeVars
fv_lhs') <- Located (HsExpr GhcPs) -> TcM (LHsExpr GhcRn, FreeVars)
rnLExpr Located (HsExpr GhcPs)
lhs
       ; (LHsExpr GhcRn
rhs', FreeVars
fv_rhs') <- Located (HsExpr GhcPs) -> TcM (LHsExpr GhcRn, FreeVars)
rnLExpr Located (HsExpr GhcPs)
rhs
       ; CLabelString -> [Name] -> LHsExpr GhcRn -> FreeVars -> TcRn ()
checkValidRule ((SourceText, CLabelString) -> CLabelString
forall a b. (a, b) -> b
snd ((SourceText, CLabelString) -> CLabelString)
-> (SourceText, CLabelString) -> CLabelString
forall a b. (a -> b) -> a -> b
$ Located (SourceText, CLabelString) -> (SourceText, CLabelString)
forall l e. GenLocated l e -> e
unLoc Located (SourceText, CLabelString)
rule_name) [Name]
names LHsExpr GhcRn
lhs' FreeVars
fv_lhs'
       ; (RuleDecl GhcRn, FreeVars) -> RnM (RuleDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (HsRule :: forall pass.
XHsRule pass
-> Located (SourceText, CLabelString)
-> Activation
-> Maybe [LHsTyVarBndr () (NoGhcTc pass)]
-> [LRuleBndr pass]
-> Located (HsExpr pass)
-> Located (HsExpr pass)
-> RuleDecl pass
HsRule { rd_ext :: XHsRule GhcRn
rd_ext  = FreeVars -> FreeVars -> HsRuleRn
HsRuleRn FreeVars
fv_lhs' FreeVars
fv_rhs'
                        , rd_name :: Located (SourceText, CLabelString)
rd_name = Located (SourceText, CLabelString)
rule_name
                        , rd_act :: Activation
rd_act  = Activation
act
                        , rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc GhcRn)]
rd_tyvs = Maybe [LHsTyVarBndr () GhcRn]
Maybe [LHsTyVarBndr () (NoGhcTc GhcRn)]
tyvs'
                        , rd_tmvs :: [LRuleBndr GhcRn]
rd_tmvs = [LRuleBndr GhcRn]
tmvs'
                        , rd_lhs :: LHsExpr GhcRn
rd_lhs  = LHsExpr GhcRn
lhs'
                        , rd_rhs :: LHsExpr GhcRn
rd_rhs  = LHsExpr GhcRn
rhs' }, FreeVars
fv_lhs' FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_rhs') } }
  where
    get_var :: RuleBndr GhcPs -> Located RdrName
    get_var :: RuleBndr GhcPs -> Located RdrName
get_var (RuleBndrSig XRuleBndrSig GhcPs
_ Located (IdP GhcPs)
v HsPatSigType GhcPs
_) = Located RdrName
Located (IdP GhcPs)
v
    get_var (RuleBndr XCRuleBndr GhcPs
_ Located (IdP GhcPs)
v)      = Located RdrName
Located (IdP GhcPs)
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
  = [LRuleBndr GhcPs]
-> [Name]
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
go [LRuleBndr GhcPs]
vars [Name]
names (([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars))
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ [LRuleBndr 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]
vars')
  where
    go :: [LRuleBndr GhcPs]
-> [Name]
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
go ((L SrcSpan
l (RuleBndr XCRuleBndr GhcPs
_ (L SrcSpan
loc IdP GhcPs
_))) : [LRuleBndr GhcPs]
vars) (Name
n : [Name]
ns) [LRuleBndr GhcRn] -> RnM (a, FreeVars)
thing_inside
      = [LRuleBndr GhcPs]
-> [Name]
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
go [LRuleBndr GhcPs]
vars [Name]
ns (([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars))
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ [LRuleBndr GhcRn]
vars' ->
        [LRuleBndr GhcRn] -> RnM (a, FreeVars)
thing_inside (SrcSpan -> RuleBndr GhcRn -> LRuleBndr GhcRn
forall l e. l -> e -> GenLocated l e
L SrcSpan
l (XCRuleBndr GhcRn -> Located (IdP GhcRn) -> RuleBndr GhcRn
forall pass. XCRuleBndr pass -> Located (IdP pass) -> RuleBndr pass
RuleBndr NoExtField
XCRuleBndr GhcRn
noExtField (SrcSpan -> Name -> Located Name
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc Name
n)) LRuleBndr GhcRn -> [LRuleBndr GhcRn] -> [LRuleBndr GhcRn]
forall a. a -> [a] -> [a]
: [LRuleBndr GhcRn]
vars')

    go ((L SrcSpan
l (RuleBndrSig XRuleBndrSig GhcPs
_ (L SrcSpan
loc IdP GhcPs
_) HsPatSigType GhcPs
bsig)) : [LRuleBndr GhcPs]
vars)
       (Name
n : [Name]
ns) [LRuleBndr GhcRn] -> RnM (a, FreeVars)
thing_inside
      = HsSigWcTypeScoping
-> HsDocContext
-> HsPatSigType GhcPs
-> (HsPatSigType GhcRn -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
forall a.
HsSigWcTypeScoping
-> HsDocContext
-> HsPatSigType GhcPs
-> (HsPatSigType GhcRn -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnHsPatSigType HsSigWcTypeScoping
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' ->
        [LRuleBndr GhcPs]
-> [Name]
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
go [LRuleBndr GhcPs]
vars [Name]
ns (([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars))
-> ([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ [LRuleBndr GhcRn]
vars' ->
        [LRuleBndr GhcRn] -> RnM (a, FreeVars)
thing_inside (SrcSpan -> RuleBndr GhcRn -> LRuleBndr GhcRn
forall l e. l -> e -> GenLocated l e
L SrcSpan
l (XRuleBndrSig GhcRn
-> Located (IdP GhcRn) -> HsPatSigType GhcRn -> RuleBndr GhcRn
forall pass.
XRuleBndrSig pass
-> Located (IdP pass) -> HsPatSigType pass -> RuleBndr pass
RuleBndrSig NoExtField
XRuleBndrSig GhcRn
noExtField (SrcSpan -> Name -> Located Name
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc Name
n) HsPatSigType GhcRn
bsig') LRuleBndr GhcRn -> [LRuleBndr GhcRn] -> [LRuleBndr GhcRn]
forall a. a -> [a] -> [a]
: [LRuleBndr GhcRn]
vars')

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

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

bindRuleTyVars :: HsDocContext -> Maybe [LHsTyVarBndr () GhcPs]
               -> (Maybe [LHsTyVarBndr () GhcRn]  -> RnM (b, FreeVars))
               -> RnM (b, FreeVars)
bindRuleTyVars :: forall b.
HsDocContext
-> Maybe [LHsTyVarBndr () GhcPs]
-> (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindRuleTyVars HsDocContext
doc (Just [LHsTyVarBndr () GhcPs]
bndrs) Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
thing_inside
  = HsDocContext
-> WarnUnusedForalls
-> Maybe Any
-> [LHsTyVarBndr () GhcPs]
-> ([LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
forall flag a b.
OutputableBndrFlag flag =>
HsDocContext
-> WarnUnusedForalls
-> Maybe a
-> [LHsTyVarBndr flag GhcPs]
-> ([LHsTyVarBndr flag GhcRn] -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindLHsTyVarBndrs HsDocContext
doc WarnUnusedForalls
WarnUnusedForalls Maybe Any
forall a. Maybe a
Nothing [LHsTyVarBndr () GhcPs]
bndrs (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars)
thing_inside (Maybe [LHsTyVarBndr () GhcRn] -> RnM (b, FreeVars))
-> ([LHsTyVarBndr () GhcRn] -> Maybe [LHsTyVarBndr () GhcRn])
-> [LHsTyVarBndr () GhcRn]
-> RnM (b, FreeVars)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [LHsTyVarBndr () GhcRn] -> Maybe [LHsTyVarBndr () 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]
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 simmpler not to check at all, and that is why
check_e is commented out.
-}

checkValidRule :: FastString -> [Name] -> LHsExpr GhcRn -> NameSet -> RnM ()
checkValidRule :: CLabelString -> [Name] -> LHsExpr GhcRn -> FreeVars -> TcRn ()
checkValidRule CLabelString
rule_name [Name]
ids LHsExpr GhcRn
lhs' FreeVars
fv_lhs'
  = do  {       -- Check for the form of the LHS
          case ([Name] -> LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
validRuleLhs [Name]
ids LHsExpr GhcRn
lhs') of
                Maybe (HsExpr GhcRn)
Nothing  -> () -> TcRn ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                Just HsExpr GhcRn
bad -> SDoc -> TcRn ()
forall a. SDoc -> TcM a
failWithTc (CLabelString -> LHsExpr GhcRn -> HsExpr GhcRn -> SDoc
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_ (SDoc -> TcRn ()
addErr (SDoc -> TcRn ()) -> (Name -> SDoc) -> Name -> TcRn ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CLabelString -> Name -> SDoc
badRuleVar 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
  = LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
checkl LHsExpr GhcRn
lhs
  where
    checkl :: LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
checkl = HsExpr GhcRn -> Maybe (HsExpr GhcRn)
check (HsExpr GhcRn -> Maybe (HsExpr GhcRn))
-> (LHsExpr GhcRn -> HsExpr GhcRn)
-> LHsExpr GhcRn
-> Maybe (HsExpr GhcRn)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LHsExpr 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)              = LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
checkl LHsExpr GhcRn
op Maybe (HsExpr GhcRn)
-> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
forall {p} {a}. p -> Maybe a
checkl_e LHsExpr GhcRn
e1
                                                      Maybe (HsExpr GhcRn)
-> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
forall {p} {a}. p -> Maybe a
checkl_e LHsExpr GhcRn
e2
    check (HsApp XApp GhcRn
_ LHsExpr GhcRn
e1 LHsExpr GhcRn
e2)                 = LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
checkl LHsExpr GhcRn
e1 Maybe (HsExpr GhcRn)
-> Maybe (HsExpr GhcRn) -> Maybe (HsExpr GhcRn)
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
forall {p} {a}. p -> Maybe a
checkl_e LHsExpr GhcRn
e2
    check (HsAppType XAppTypeE GhcRn
_ LHsExpr GhcRn
e LHsWcType (NoGhcTc GhcRn)
_)               = LHsExpr GhcRn -> Maybe (HsExpr GhcRn)
checkl LHsExpr GhcRn
e
    check (HsVar XVar GhcRn
_ Located (IdP GhcRn)
lv)
      | (Located Name -> Name
forall l e. GenLocated l e -> e
unLoc Located Name
Located (IdP GhcRn)
lv) Name -> [Name] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Name]
foralls      = Maybe (HsExpr GhcRn)
forall a. Maybe a
Nothing
    check HsExpr GhcRn
other                           = HsExpr GhcRn -> Maybe (HsExpr GhcRn)
forall a. a -> Maybe a
Just HsExpr GhcRn
other  -- Failure

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

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

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

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

badRuleVar :: FastString -> Name -> SDoc
badRuleVar :: CLabelString -> Name -> SDoc
badRuleVar CLabelString
name Name
var
  = [SDoc] -> SDoc
sep [String -> SDoc
text String
"Rule" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
doubleQuotes (CLabelString -> SDoc
ftext CLabelString
name) SDoc -> SDoc -> SDoc
<> SDoc
colon,
         String -> SDoc
text String
"Forall'd variable" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
var) SDoc -> SDoc -> SDoc
<+>
                String -> SDoc
text String
"does not appear on left hand side"]

badRuleLhsErr :: FastString -> LHsExpr GhcRn -> HsExpr GhcRn -> SDoc
badRuleLhsErr :: CLabelString -> LHsExpr GhcRn -> HsExpr GhcRn -> SDoc
badRuleLhsErr CLabelString
name LHsExpr GhcRn
lhs HsExpr GhcRn
bad_e
  = [SDoc] -> SDoc
sep [String -> SDoc
text String
"Rule" SDoc -> SDoc -> SDoc
<+> CLabelString -> SDoc
pprRuleName CLabelString
name SDoc -> SDoc -> SDoc
<> SDoc
colon,
         Int -> SDoc -> SDoc
nest Int
2 ([SDoc] -> SDoc
vcat [SDoc
err,
                       String -> SDoc
text String
"in left-hand side:" SDoc -> SDoc -> SDoc
<+> LHsExpr GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr GhcRn
lhs])]
    SDoc -> SDoc -> SDoc
$$
    String -> SDoc
text String
"LHS must be of form (f e1 .. en) where f is not forall'd"
  where
    err :: SDoc
err = case HsExpr GhcRn
bad_e of
            HsUnboundVar XUnboundVar GhcRn
_ OccName
uv -> RdrName -> SDoc
notInScopeErr (OccName -> RdrName
mkRdrUnqual OccName
uv)
            HsExpr GhcRn
_                 -> String -> SDoc
text String
"Illegal expression:" SDoc -> SDoc -> SDoc
<+> HsExpr GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr GhcRn
bad_e

{- **************************************************************
         *                                                      *
      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
comoponent 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 declaraations
       ; [(LTyClDecl GhcRn, FreeVars)]
tycls_w_fvs <- (Located (TyClDecl GhcPs)
 -> IOEnv (Env TcGblEnv TcLclEnv) (LTyClDecl GhcRn, FreeVars))
-> [Located (TyClDecl GhcPs)]
-> IOEnv (Env TcGblEnv TcLclEnv) [(LTyClDecl GhcRn, FreeVars)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((TyClDecl GhcPs -> TcM (TyClDecl GhcRn, FreeVars))
-> Located (TyClDecl GhcPs)
-> IOEnv (Env TcGblEnv TcLclEnv) (LTyClDecl GhcRn, FreeVars)
forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM TyClDecl GhcPs -> TcM (TyClDecl GhcRn, FreeVars)
rnTyClDecl) ([TyClGroup GhcPs] -> [Located (TyClDecl GhcPs)]
forall pass. [TyClGroup pass] -> [LTyClDecl pass]
tyClGroupTyClDecls [TyClGroup GhcPs]
tycl_ds)
       ; let tc_names :: FreeVars
tc_names = [Name] -> FreeVars
mkNameSet (((LTyClDecl GhcRn, FreeVars) -> Name)
-> [(LTyClDecl GhcRn, FreeVars)] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map (TyClDecl GhcRn -> Name
forall (p :: Pass). TyClDecl (GhcPass p) -> IdP (GhcPass p)
tcdName (TyClDecl GhcRn -> Name)
-> ((LTyClDecl GhcRn, FreeVars) -> TyClDecl GhcRn)
-> (LTyClDecl GhcRn, FreeVars)
-> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LTyClDecl GhcRn -> TyClDecl GhcRn
forall l e. GenLocated l e -> e
unLoc (LTyClDecl GhcRn -> TyClDecl GhcRn)
-> ((LTyClDecl GhcRn, FreeVars) -> LTyClDecl GhcRn)
-> (LTyClDecl GhcRn, FreeVars)
-> TyClDecl GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LTyClDecl GhcRn, FreeVars) -> LTyClDecl GhcRn
forall a b. (a, b) -> a
fst) [(LTyClDecl GhcRn, FreeVars)]
tycls_w_fvs)
       ; [(LStandaloneKindSig GhcRn, FreeVars)]
kisigs_w_fvs <- FreeVars
-> [LStandaloneKindSig GhcPs]
-> RnM [(LStandaloneKindSig GhcRn, FreeVars)]
rnStandaloneKindSignatures FreeVars
tc_names ([TyClGroup GhcPs] -> [LStandaloneKindSig GhcPs]
forall pass. [TyClGroup pass] -> [LStandaloneKindSig pass]
tyClGroupKindSigs [TyClGroup GhcPs]
tycl_ds)
       ; [(Located (InstDecl GhcRn), FreeVars)]
instds_w_fvs <- (Located (InstDecl GhcPs)
 -> IOEnv
      (Env TcGblEnv TcLclEnv) (Located (InstDecl GhcRn), FreeVars))
-> [Located (InstDecl GhcPs)]
-> IOEnv
     (Env TcGblEnv TcLclEnv) [(Located (InstDecl GhcRn), FreeVars)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((InstDecl GhcPs -> RnM (InstDecl GhcRn, FreeVars))
-> Located (InstDecl GhcPs)
-> IOEnv
     (Env TcGblEnv TcLclEnv) (Located (InstDecl GhcRn), FreeVars)
forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM InstDecl GhcPs -> RnM (InstDecl GhcRn, FreeVars)
rnSrcInstDecl) ([TyClGroup GhcPs] -> [Located (InstDecl GhcPs)]
forall pass. [TyClGroup pass] -> [LInstDecl pass]
tyClGroupInstDecls [TyClGroup GhcPs]
tycl_ds)
       ; [LRoleAnnotDecl GhcRn]
role_annots  <- FreeVars -> [LRoleAnnotDecl GhcPs] -> RnM [LRoleAnnotDecl GhcRn]
rnRoleAnnots FreeVars
tc_names ([TyClGroup GhcPs] -> [LRoleAnnotDecl GhcPs]
forall pass. [TyClGroup pass] -> [LRoleAnnotDecl pass]
tyClGroupRoleDecls [TyClGroup GhcPs]
tycl_ds)

       -- Do SCC analysis on the type/class decls
       ; GlobalRdrEnv
rdr_env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
       ; let tycl_sccs :: [SCC (LTyClDecl GhcRn)]
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)]
tycls_w_fvs
             role_annot_env :: RoleAnnotEnv
role_annot_env = [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
mkRoleAnnotEnv [LRoleAnnotDecl GhcRn]
role_annots
             (KindSigEnv
kisig_env, KindSig_FV_Env
kisig_fv_env) = [(LStandaloneKindSig GhcRn, FreeVars)]
-> (KindSigEnv, KindSig_FV_Env)
mkKindSig_fv_env [(LStandaloneKindSig GhcRn, FreeVars)]
kisigs_w_fvs

             inst_ds_map :: [(Located (InstDecl GhcRn), FreeVars)]
inst_ds_map = GlobalRdrEnv
-> FreeVars
-> [(Located (InstDecl GhcRn), FreeVars)]
-> [(Located (InstDecl GhcRn), FreeVars)]
mkInstDeclFreeVarsMap GlobalRdrEnv
rdr_env FreeVars
tc_names [(Located (InstDecl GhcRn), FreeVars)]
instds_w_fvs
             ([Located (InstDecl GhcRn)]
init_inst_ds, [(Located (InstDecl GhcRn), FreeVars)]
rest_inst_ds) = [Name]
-> [(Located (InstDecl GhcRn), FreeVars)]
-> ([Located (InstDecl GhcRn)],
    [(Located (InstDecl GhcRn), FreeVars)])
getInsts [] [(Located (InstDecl GhcRn), FreeVars)]
inst_ds_map

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

             ([(Located (InstDecl GhcRn), FreeVars)]
final_inst_ds, [TyClGroup GhcRn]
groups)
                = ([(Located (InstDecl GhcRn), FreeVars)]
 -> SCC (LTyClDecl GhcRn)
 -> ([(Located (InstDecl GhcRn), FreeVars)], TyClGroup GhcRn))
-> [(Located (InstDecl GhcRn), FreeVars)]
-> [SCC (LTyClDecl GhcRn)]
-> ([(Located (InstDecl GhcRn), FreeVars)], [TyClGroup GhcRn])
forall (t :: * -> *) s a b.
Traversable t =>
(s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL (RoleAnnotEnv
-> KindSigEnv
-> [(Located (InstDecl GhcRn), FreeVars)]
-> SCC (LTyClDecl GhcRn)
-> ([(Located (InstDecl GhcRn), FreeVars)], TyClGroup GhcRn)
mk_group RoleAnnotEnv
role_annot_env KindSigEnv
kisig_env) [(Located (InstDecl GhcRn), FreeVars)]
rest_inst_ds [SCC (LTyClDecl GhcRn)]
tycl_sccs

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

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

       ; MASSERT2( null final_inst_ds,  ppr instds_w_fvs $$ ppr inst_ds_map
                                       $$ ppr (flattenSCCs tycl_sccs) $$ ppr final_inst_ds  )

       ; String -> SDoc -> TcRn ()
traceRn String
"rnTycl dependency analysis made groups" ([TyClGroup GhcRn] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TyClGroup GhcRn]
all_groups)
       ; ([TyClGroup GhcRn], FreeVars) -> RnM ([TyClGroup GhcRn], FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TyClGroup GhcRn]
all_groups, FreeVars
all_fvs) }
  where
    mk_group :: RoleAnnotEnv
             -> KindSigEnv
             -> InstDeclFreeVarsMap
             -> SCC (LTyClDecl GhcRn)
             -> (InstDeclFreeVarsMap, TyClGroup GhcRn)
    mk_group :: RoleAnnotEnv
-> KindSigEnv
-> [(Located (InstDecl GhcRn), FreeVars)]
-> SCC (LTyClDecl GhcRn)
-> ([(Located (InstDecl GhcRn), FreeVars)], TyClGroup GhcRn)
mk_group RoleAnnotEnv
role_env KindSigEnv
kisig_env [(Located (InstDecl GhcRn), FreeVars)]
inst_map SCC (LTyClDecl GhcRn)
scc
      = ([(Located (InstDecl GhcRn), FreeVars)]
inst_map', TyClGroup GhcRn
group)
      where
        tycl_ds :: [LTyClDecl GhcRn]
tycl_ds              = SCC (LTyClDecl GhcRn) -> [LTyClDecl GhcRn]
forall vertex. SCC vertex -> [vertex]
flattenSCC SCC (LTyClDecl GhcRn)
scc
        bndrs :: [Name]
bndrs                = (LTyClDecl GhcRn -> Name) -> [LTyClDecl GhcRn] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map (TyClDecl GhcRn -> Name
forall (p :: Pass). TyClDecl (GhcPass p) -> IdP (GhcPass p)
tcdName (TyClDecl GhcRn -> Name)
-> (LTyClDecl GhcRn -> TyClDecl GhcRn) -> LTyClDecl GhcRn -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LTyClDecl GhcRn -> TyClDecl GhcRn
forall l e. GenLocated l e -> e
unLoc) [LTyClDecl 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
        ([Located (InstDecl GhcRn)]
inst_ds, [(Located (InstDecl GhcRn), FreeVars)]
inst_map') = [Name]
-> [(Located (InstDecl GhcRn), FreeVars)]
-> ([Located (InstDecl GhcRn)],
    [(Located (InstDecl GhcRn), FreeVars)])
getInsts      [Name]
bndrs [(Located (InstDecl GhcRn), FreeVars)]
inst_map
        group :: TyClGroup GhcRn
group = TyClGroup :: forall pass.
XCTyClGroup pass
-> [LTyClDecl pass]
-> [LRoleAnnotDecl pass]
-> [LStandaloneKindSig pass]
-> [LInstDecl pass]
-> TyClGroup pass
TyClGroup { group_ext :: XCTyClGroup GhcRn
group_ext    = NoExtField
XCTyClGroup GhcRn
noExtField
                          , group_tyclds :: [LTyClDecl GhcRn]
group_tyclds = [LTyClDecl GhcRn]
tycl_ds
                          , group_kisigs :: [LStandaloneKindSig GhcRn]
group_kisigs = [LStandaloneKindSig GhcRn]
kisigs
                          , group_roles :: [LRoleAnnotDecl GhcRn]
group_roles  = [LRoleAnnotDecl GhcRn]
roles
                          , group_instds :: [Located (InstDecl GhcRn)]
group_instds = [Located (InstDecl 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
kisig_env, KindSig_FV_Env
kisig_fv_env)
  where
    kisig_env :: KindSigEnv
kisig_env = ((LStandaloneKindSig GhcRn, FreeVars) -> LStandaloneKindSig GhcRn)
-> NameEnv (LStandaloneKindSig GhcRn, FreeVars) -> KindSigEnv
forall elt1 elt2. (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
mapNameEnv (LStandaloneKindSig GhcRn, FreeVars) -> LStandaloneKindSig GhcRn
forall a b. (a, b) -> a
fst NameEnv (LStandaloneKindSig GhcRn, FreeVars)
compound_env
    kisig_fv_env :: KindSig_FV_Env
kisig_fv_env = NameEnv FreeVars -> KindSig_FV_Env
KindSig_FV_Env (((LStandaloneKindSig GhcRn, FreeVars) -> FreeVars)
-> NameEnv (LStandaloneKindSig GhcRn, FreeVars) -> NameEnv FreeVars
forall elt1 elt2. (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
mapNameEnv (LStandaloneKindSig GhcRn, FreeVars) -> FreeVars
forall a b. (a, b) -> b
snd NameEnv (LStandaloneKindSig GhcRn, FreeVars)
compound_env)
    NameEnv (LStandaloneKindSig GhcRn, FreeVars)
compound_env :: NameEnv (LStandaloneKindSig GhcRn, FreeVars)
      = ((LStandaloneKindSig GhcRn, FreeVars) -> Name)
-> [(LStandaloneKindSig GhcRn, FreeVars)]
-> NameEnv (LStandaloneKindSig GhcRn, FreeVars)
forall a. (a -> Name) -> [a] -> NameEnv a
mkNameEnvWith (StandaloneKindSig GhcRn -> Name
forall (p :: Pass).
StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
standaloneKindSigName (StandaloneKindSig GhcRn -> Name)
-> ((LStandaloneKindSig GhcRn, FreeVars)
    -> StandaloneKindSig GhcRn)
-> (LStandaloneKindSig GhcRn, FreeVars)
-> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LStandaloneKindSig GhcRn -> StandaloneKindSig GhcRn
forall l e. GenLocated l e -> e
unLoc (LStandaloneKindSig GhcRn -> StandaloneKindSig GhcRn)
-> ((LStandaloneKindSig GhcRn, FreeVars)
    -> LStandaloneKindSig GhcRn)
-> (LStandaloneKindSig GhcRn, FreeVars)
-> StandaloneKindSig GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LStandaloneKindSig GhcRn, FreeVars) -> LStandaloneKindSig GhcRn
forall a b. (a, b) -> a
fst) [(LStandaloneKindSig GhcRn, FreeVars)]
kisigs_w_fvs

getKindSigs :: [Name] -> KindSigEnv -> [LStandaloneKindSig GhcRn]
getKindSigs :: [Name] -> KindSigEnv -> [LStandaloneKindSig GhcRn]
getKindSigs [Name]
bndrs KindSigEnv
kisig_env = (Name -> Maybe (LStandaloneKindSig GhcRn))
-> [Name] -> [LStandaloneKindSig GhcRn]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (KindSigEnv -> Name -> Maybe (LStandaloneKindSig GhcRn)
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv KindSigEnv
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 ([LStandaloneKindSig GhcPs]
no_dups, [NonEmpty (LStandaloneKindSig GhcPs)]
dup_kisigs) = (LStandaloneKindSig GhcPs -> LStandaloneKindSig GhcPs -> Ordering)
-> [LStandaloneKindSig GhcPs]
-> ([LStandaloneKindSig GhcPs],
    [NonEmpty (LStandaloneKindSig GhcPs)])
forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
removeDups (RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (RdrName -> RdrName -> Ordering)
-> (LStandaloneKindSig GhcPs -> RdrName)
-> LStandaloneKindSig GhcPs
-> LStandaloneKindSig GhcPs
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` LStandaloneKindSig GhcPs -> RdrName
forall {l} {p :: Pass}.
GenLocated l (StandaloneKindSig (GhcPass p)) -> IdGhcP p
get_name) [LStandaloneKindSig GhcPs]
kisigs
             get_name :: GenLocated l (StandaloneKindSig (GhcPass p)) -> IdGhcP p
get_name = 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 (LStandaloneKindSig GhcPs) -> TcRn ())
-> [NonEmpty (LStandaloneKindSig GhcPs)] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ NonEmpty (LStandaloneKindSig GhcPs) -> TcRn ()
dupKindSig_Err [NonEmpty (LStandaloneKindSig GhcPs)]
dup_kisigs
       ; (LStandaloneKindSig GhcPs
 -> IOEnv
      (Env TcGblEnv TcLclEnv) (LStandaloneKindSig GhcRn, FreeVars))
-> [LStandaloneKindSig GhcPs]
-> RnM [(LStandaloneKindSig GhcRn, FreeVars)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((StandaloneKindSig GhcPs
 -> TcM (StandaloneKindSig GhcRn, FreeVars))
-> LStandaloneKindSig GhcPs
-> IOEnv
     (Env TcGblEnv TcLclEnv) (LStandaloneKindSig GhcRn, FreeVars)
forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM (FreeVars
-> StandaloneKindSig GhcPs
-> TcM (StandaloneKindSig GhcRn, FreeVars)
rnStandaloneKindSignature FreeVars
tc_names)) [LStandaloneKindSig 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
_ Located (IdP GhcPs)
v LHsSigType GhcPs
ki)
  = do  { Bool
standalone_ki_sig_ok <- Extension -> TcRn Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.StandaloneKindSignatures
        ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
standalone_ki_sig_ok (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ SDoc -> TcRn ()
addErr SDoc
standaloneKiSigErr
        ; Located Name
new_v <- HsSigCtxt -> SDoc -> Located RdrName -> RnM (Located Name)
lookupSigCtxtOccRn (FreeVars -> HsSigCtxt
TopSigCtxt FreeVars
tc_names) (String -> SDoc
text String
"standalone kind signature") Located RdrName
Located (IdP GhcPs)
v
        ; let doc :: HsDocContext
doc = SDoc -> HsDocContext
StandaloneKindSigCtx (Located RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr Located RdrName
Located (IdP GhcPs)
v)
        ; (LHsSigType GhcRn
new_ki, FreeVars
fvs) <- HsDocContext
-> TypeOrKind
-> LHsSigType GhcPs
-> RnM (LHsSigType GhcRn, FreeVars)
rnHsSigType HsDocContext
doc TypeOrKind
KindLevel LHsSigType GhcPs
ki
        ; (StandaloneKindSig GhcRn, FreeVars)
-> TcM (StandaloneKindSig GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XStandaloneKindSig GhcRn
-> Located (IdP GhcRn)
-> LHsSigType GhcRn
-> StandaloneKindSig GhcRn
forall pass.
XStandaloneKindSig pass
-> Located (IdP pass) -> LHsSigType pass -> StandaloneKindSig pass
StandaloneKindSig NoExtField
XStandaloneKindSig GhcRn
noExtField Located Name
Located (IdP GhcRn)
new_v LHsSigType GhcRn
new_ki, FreeVars
fvs)
        }
  where
    standaloneKiSigErr :: SDoc
    standaloneKiSigErr :: SDoc
standaloneKiSigErr =
      SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Illegal standalone kind signature")
         Int
2 (String -> SDoc
text String
"Did you mean to enable StandaloneKindSignatures?")

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 (LTyClDecl GhcRn)] -> [SCC (LTyClDecl GhcRn)]
forall key payload.
Uniquable key =>
[Node key payload] -> [SCC payload]
stronglyConnCompFromEdgedVerticesUniq [Node Name (LTyClDecl GhcRn)]
edges
  where
    edges :: [ Node Name (LTyClDecl GhcRn) ]
    edges :: [Node Name (LTyClDecl GhcRn)]
edges = [ LTyClDecl GhcRn -> Name -> [Name] -> Node Name (LTyClDecl GhcRn)
forall key payload. payload -> key -> [key] -> Node key payload
DigraphNode LTyClDecl GhcRn
d Name
IdP GhcRn
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))
            | (LTyClDecl GhcRn
d, FreeVars
fvs) <- [(LTyClDecl GhcRn, FreeVars)]
ds_w_fvs,
              let { name :: IdP GhcRn
name = TyClDecl GhcRn -> IdP GhcRn
forall (p :: Pass). TyClDecl (GhcPass p) -> IdP (GhcPass p)
tcdName (LTyClDecl GhcRn -> TyClDecl GhcRn
forall l e. GenLocated l e -> e
unLoc LTyClDecl GhcRn
d)
                  ; kisig_fvs :: FreeVars
kisig_fvs = KindSig_FV_Env -> Name -> FreeVars
lookupKindSig_FV_Env KindSig_FV_Env
kisig_fv_env Name
IdP GhcRn
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 GlobalRdrElt
lookupGRE_Name GlobalRdrEnv
rdr_env Name
n of
      Just GlobalRdrElt
gre -> case GlobalRdrElt -> Parent
gre_par GlobalRdrElt
gre of
                    ParentIs  { par_is :: Parent -> Name
par_is = Name
p } -> Name
p
                    FldParent { par_is :: Parent -> Name
par_is = Name
p } -> Name
p
                    Parent
_                        -> Name
n
      Maybe GlobalRdrElt
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 ([LRoleAnnotDecl GhcPs]
no_dups, [NonEmpty (LRoleAnnotDecl GhcPs)]
dup_annots) = (LRoleAnnotDecl GhcPs -> LRoleAnnotDecl GhcPs -> Ordering)
-> [LRoleAnnotDecl GhcPs]
-> ([LRoleAnnotDecl GhcPs], [NonEmpty (LRoleAnnotDecl GhcPs)])
forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
removeDups (RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (RdrName -> RdrName -> Ordering)
-> (LRoleAnnotDecl GhcPs -> RdrName)
-> LRoleAnnotDecl GhcPs
-> LRoleAnnotDecl GhcPs
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` LRoleAnnotDecl GhcPs -> RdrName
forall {l} {p :: Pass}.
GenLocated l (RoleAnnotDecl (GhcPass p)) -> IdGhcP p
get_name) [LRoleAnnotDecl GhcPs]
role_annots
             get_name :: GenLocated l (RoleAnnotDecl (GhcPass p)) -> IdGhcP p
get_name = 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 (LRoleAnnotDecl GhcPs) -> TcRn ())
-> [NonEmpty (LRoleAnnotDecl GhcPs)] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ NonEmpty (LRoleAnnotDecl GhcPs) -> TcRn ()
dupRoleAnnotErr [NonEmpty (LRoleAnnotDecl GhcPs)]
dup_annots
       ; (LRoleAnnotDecl GhcPs
 -> IOEnv (Env TcGblEnv TcLclEnv) (LRoleAnnotDecl GhcRn))
-> [LRoleAnnotDecl GhcPs] -> RnM [LRoleAnnotDecl GhcRn]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn))
-> LRoleAnnotDecl GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (LRoleAnnotDecl GhcRn)
forall a b. (a -> TcM b) -> Located a -> TcM (Located b)
wrapLocM RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn)
rn_role_annot1) [LRoleAnnotDecl GhcPs]
no_dups }
  where
    rn_role_annot1 :: RoleAnnotDecl GhcPs -> TcM (RoleAnnotDecl GhcRn)
rn_role_annot1 (RoleAnnotDecl XCRoleAnnotDecl GhcPs
_ Located (IdP GhcPs)
tycon [Located (Maybe Role)]
roles)
      = do {  -- the name is an *occurrence*, but look it up only in the
              -- decls defined in this group (see #10263)
             Located Name
tycon' <- HsSigCtxt -> SDoc -> Located RdrName -> RnM (Located Name)
lookupSigCtxtOccRn (FreeVars -> HsSigCtxt
RoleAnnotCtxt FreeVars
tc_names)
                                          (String -> SDoc
text String
"role annotation")
                                          Located RdrName
Located (IdP GhcPs)
tycon
           ; RoleAnnotDecl GhcRn -> TcM (RoleAnnotDecl GhcRn)
forall (m :: * -> *) a. Monad m => a -> m a
return (RoleAnnotDecl GhcRn -> TcM (RoleAnnotDecl GhcRn))
-> RoleAnnotDecl GhcRn -> TcM (RoleAnnotDecl GhcRn)
forall a b. (a -> b) -> a -> b
$ XCRoleAnnotDecl GhcRn
-> Located (IdP GhcRn)
-> [Located (Maybe Role)]
-> RoleAnnotDecl GhcRn
forall pass.
XCRoleAnnotDecl pass
-> Located (IdP pass)
-> [Located (Maybe Role)]
-> RoleAnnotDecl pass
RoleAnnotDecl NoExtField
XCRoleAnnotDecl GhcRn
noExtField Located Name
Located (IdP GhcRn)
tycon' [Located (Maybe Role)]
roles }

dupRoleAnnotErr :: NonEmpty (LRoleAnnotDecl GhcPs) -> RnM ()
dupRoleAnnotErr :: NonEmpty (LRoleAnnotDecl GhcPs) -> TcRn ()
dupRoleAnnotErr NonEmpty (LRoleAnnotDecl GhcPs)
list
  = SrcSpan -> SDoc -> TcRn ()
addErrAt SrcSpan
loc (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$
    SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Duplicate role annotations for" SDoc -> SDoc -> SDoc
<+>
          SDoc -> SDoc
quotes (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (RdrName -> SDoc) -> RdrName -> SDoc
forall a b. (a -> b) -> a -> b
$ RoleAnnotDecl GhcPs -> IdP GhcPs
forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
roleAnnotDeclName RoleAnnotDecl GhcPs
first_decl) SDoc -> SDoc -> SDoc
<> SDoc
colon)
       Int
2 ([SDoc] -> SDoc
vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
forall a b. (a -> b) -> a -> b
$ (LRoleAnnotDecl GhcPs -> SDoc) -> [LRoleAnnotDecl GhcPs] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LRoleAnnotDecl GhcPs -> SDoc
forall {a} {a}.
(Outputable a, Outputable a) =>
GenLocated a a -> SDoc
pp_role_annot ([LRoleAnnotDecl GhcPs] -> [SDoc])
-> [LRoleAnnotDecl GhcPs] -> [SDoc]
forall a b. (a -> b) -> a -> b
$ NonEmpty (LRoleAnnotDecl GhcPs) -> [LRoleAnnotDecl GhcPs]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (LRoleAnnotDecl GhcPs)
sorted_list)
    where
      sorted_list :: NonEmpty (LRoleAnnotDecl GhcPs)
sorted_list = (LRoleAnnotDecl GhcPs -> LRoleAnnotDecl GhcPs -> Ordering)
-> NonEmpty (LRoleAnnotDecl GhcPs)
-> NonEmpty (LRoleAnnotDecl GhcPs)
forall a. (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
NE.sortBy LRoleAnnotDecl GhcPs -> LRoleAnnotDecl GhcPs -> Ordering
forall {e}.
GenLocated SrcSpan e -> GenLocated SrcSpan e -> Ordering
cmp_loc NonEmpty (LRoleAnnotDecl GhcPs)
list
      ((L SrcSpan
loc RoleAnnotDecl GhcPs
first_decl) :| [LRoleAnnotDecl GhcPs]
_) = NonEmpty (LRoleAnnotDecl GhcPs)
sorted_list

      pp_role_annot :: GenLocated a a -> SDoc
pp_role_annot (L a
loc a
decl) = SDoc -> Int -> SDoc -> SDoc
hang (a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
decl)
                                      Int
4 (String -> SDoc
text String
"-- written at" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
loc)

      cmp_loc :: GenLocated SrcSpan e -> GenLocated SrcSpan e -> Ordering
cmp_loc = SrcSpan -> SrcSpan -> Ordering
SrcLoc.leftmost_smallest (SrcSpan -> SrcSpan -> Ordering)
-> (GenLocated SrcSpan e -> SrcSpan)
-> GenLocated SrcSpan e
-> GenLocated SrcSpan e
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` GenLocated SrcSpan e -> SrcSpan
forall l e. GenLocated l e -> l
getLoc

dupKindSig_Err :: NonEmpty (LStandaloneKindSig GhcPs) -> RnM ()
dupKindSig_Err :: NonEmpty (LStandaloneKindSig GhcPs) -> TcRn ()
dupKindSig_Err NonEmpty (LStandaloneKindSig GhcPs)
list
  = SrcSpan -> SDoc -> TcRn ()
addErrAt SrcSpan
loc (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$
    SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Duplicate standalone kind signatures for" SDoc -> SDoc -> SDoc
<+>
          SDoc -> SDoc
quotes (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (RdrName -> SDoc) -> RdrName -> SDoc
forall a b. (a -> b) -> a -> b
$ StandaloneKindSig GhcPs -> IdP GhcPs
forall (p :: Pass).
StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
standaloneKindSigName StandaloneKindSig GhcPs
first_decl) SDoc -> SDoc -> SDoc
<> SDoc
colon)
       Int
2 ([SDoc] -> SDoc
vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
forall a b. (a -> b) -> a -> b
$ (LStandaloneKindSig GhcPs -> SDoc)
-> [LStandaloneKindSig GhcPs] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LStandaloneKindSig GhcPs -> SDoc
forall {a} {a}.
(Outputable a, Outputable a) =>
GenLocated a a -> SDoc
pp_kisig ([LStandaloneKindSig GhcPs] -> [SDoc])
-> [LStandaloneKindSig GhcPs] -> [SDoc]
forall a b. (a -> b) -> a -> b
$ NonEmpty (LStandaloneKindSig GhcPs) -> [LStandaloneKindSig GhcPs]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (LStandaloneKindSig GhcPs)
sorted_list)
    where
      sorted_list :: NonEmpty (LStandaloneKindSig GhcPs)
sorted_list = (LStandaloneKindSig GhcPs -> LStandaloneKindSig GhcPs -> Ordering)
-> NonEmpty (LStandaloneKindSig GhcPs)
-> NonEmpty (LStandaloneKindSig GhcPs)
forall a. (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
NE.sortBy LStandaloneKindSig GhcPs -> LStandaloneKindSig GhcPs -> Ordering
forall {e}.
GenLocated SrcSpan e -> GenLocated SrcSpan e -> Ordering
cmp_loc NonEmpty (LStandaloneKindSig GhcPs)
list
      ((L SrcSpan
loc StandaloneKindSig GhcPs
first_decl) :| [LStandaloneKindSig GhcPs]
_) = NonEmpty (LStandaloneKindSig GhcPs)
sorted_list

      pp_kisig :: GenLocated a a -> SDoc
pp_kisig (L a
loc a
decl) =
        SDoc -> Int -> SDoc -> SDoc
hang (a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
decl) Int
4 (String -> SDoc
text String
"-- written at" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
loc)

      cmp_loc :: GenLocated SrcSpan e -> GenLocated SrcSpan e -> Ordering
cmp_loc = SrcSpan -> SrcSpan -> Ordering
SrcLoc.leftmost_smallest (SrcSpan -> SrcSpan -> Ordering)
-> (GenLocated SrcSpan e -> SrcSpan)
-> GenLocated SrcSpan e
-> GenLocated SrcSpan e
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` GenLocated SrcSpan e -> SrcSpan
forall l e. GenLocated l e -> l
getLoc

{- 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
-> [(Located (InstDecl GhcRn), FreeVars)]
-> [(Located (InstDecl GhcRn), FreeVars)]
mkInstDeclFreeVarsMap GlobalRdrEnv
rdr_env FreeVars
tycl_bndrs [(Located (InstDecl GhcRn), FreeVars)]
inst_ds_fvs
  = [ (Located (InstDecl GhcRn)
inst_decl, GlobalRdrEnv -> FreeVars -> FreeVars
toParents GlobalRdrEnv
rdr_env FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`intersectFVs` FreeVars
tycl_bndrs)
    | (Located (InstDecl GhcRn)
inst_decl, FreeVars
fvs) <- [(Located (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]
-> [(Located (InstDecl GhcRn), FreeVars)]
-> ([Located (InstDecl GhcRn)],
    [(Located (InstDecl GhcRn), FreeVars)])
getInsts [Name]
bndrs [(Located (InstDecl GhcRn), FreeVars)]
inst_decl_map
  = ((Located (InstDecl GhcRn), FreeVars)
 -> Either
      (Located (InstDecl GhcRn)) (Located (InstDecl GhcRn), FreeVars))
-> [(Located (InstDecl GhcRn), FreeVars)]
-> ([Located (InstDecl GhcRn)],
    [(Located (InstDecl GhcRn), FreeVars)])
forall a b c. (a -> Either b c) -> [a] -> ([b], [c])
partitionWith (Located (InstDecl GhcRn), FreeVars)
-> Either
     (Located (InstDecl GhcRn)) (Located (InstDecl GhcRn), FreeVars)
pick_me [(Located (InstDecl GhcRn), FreeVars)]
inst_decl_map
  where
    pick_me :: (LInstDecl GhcRn, FreeVars)
            -> Either (LInstDecl GhcRn) (LInstDecl GhcRn, FreeVars)
    pick_me :: (Located (InstDecl GhcRn), FreeVars)
-> Either
     (Located (InstDecl GhcRn)) (Located (InstDecl GhcRn), FreeVars)
pick_me (Located (InstDecl GhcRn)
decl, FreeVars
fvs)
      | FreeVars -> Bool
isEmptyNameSet FreeVars
depleted_fvs = Located (InstDecl GhcRn)
-> Either
     (Located (InstDecl GhcRn)) (Located (InstDecl GhcRn), FreeVars)
forall a b. a -> Either a b
Left Located (InstDecl GhcRn)
decl
      | Bool
otherwise                   = (Located (InstDecl GhcRn), FreeVars)
-> Either
     (Located (InstDecl GhcRn)) (Located (InstDecl GhcRn), FreeVars)
forall a b. b -> Either a b
Right (Located (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 { (FamilyDecl GhcRn
fam', FreeVars
fvs) <- Maybe Name -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
rnFamDecl Maybe Name
forall a. Maybe a
Nothing FamilyDecl GhcPs
fam
       ; (TyClDecl GhcRn, FreeVars) -> TcM (TyClDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XFamDecl GhcRn -> FamilyDecl GhcRn -> TyClDecl GhcRn
forall pass. XFamDecl pass -> FamilyDecl pass -> TyClDecl pass
FamDecl NoExtField
XFamDecl GhcRn
noExtField FamilyDecl GhcRn
fam', FreeVars
fvs) }

rnTyClDecl (SynDecl { tcdLName :: forall pass. TyClDecl pass -> Located (IdP pass)
tcdLName = Located (IdP 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 { Located Name
tycon' <- Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn Located RdrName
Located (IdP GhcPs)
tycon
       ; let kvs :: [Located RdrName]
kvs = LHsType GhcPs -> [Located RdrName]
extractHsTyRdrTyVarsKindVars LHsType GhcPs
rhs
             doc :: HsDocContext
doc = Located RdrName -> HsDocContext
TySynCtx Located RdrName
Located (IdP GhcPs)
tycon
       ; String -> SDoc -> TcRn ()
traceRn String
"rntycl-ty" (Located RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr Located RdrName
Located (IdP GhcPs)
tycon SDoc -> SDoc -> SDoc
<+> [Located RdrName] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Located RdrName]
kvs)
       ; HsDocContext
-> Maybe Any
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
-> TcM (TyClDecl GhcRn, FreeVars)
forall a b.
HsDocContext
-> Maybe a
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindHsQTyVars HsDocContext
doc Maybe Any
forall a. Maybe a
Nothing [Located RdrName]
kvs LHsQTyVars GhcPs
tyvars ((LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
 -> TcM (TyClDecl GhcRn, FreeVars))
-> (LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
-> TcM (TyClDecl GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ LHsQTyVars GhcRn
tyvars' Bool
_ ->
    do { (LHsType GhcRn
rhs', FreeVars
fvs) <- HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
rnTySyn HsDocContext
doc LHsType GhcPs
rhs
       ; (TyClDecl GhcRn, FreeVars) -> TcM (TyClDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (SynDecl :: forall pass.
XSynDecl pass
-> Located (IdP pass)
-> LHsQTyVars pass
-> LexicalFixity
-> LHsType pass
-> TyClDecl pass
SynDecl { tcdLName :: Located (IdP GhcRn)
tcdLName = Located Name
Located (IdP GhcRn)
tycon', tcdTyVars :: LHsQTyVars GhcRn
tcdTyVars = LHsQTyVars GhcRn
tyvars'
                         , tcdFixity :: LexicalFixity
tcdFixity = LexicalFixity
fixity
                         , tcdRhs :: LHsType GhcRn
tcdRhs = LHsType GhcRn
rhs', tcdSExt :: XSynDecl GhcRn
tcdSExt = FreeVars
XSynDecl GhcRn
fvs }, FreeVars
fvs) } }

-- "data", "newtype" declarations
rnTyClDecl (DataDecl
    { tcdLName :: forall pass. TyClDecl pass -> Located (IdP pass)
tcdLName = Located (IdP 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_ND :: forall pass. HsDataDefn pass -> NewOrData
dd_ND = NewOrData
new_or_data
                                   , dd_kindSig :: forall pass. HsDataDefn pass -> Maybe (LHsKind pass)
dd_kindSig = Maybe (LHsType GhcPs)
kind_sig} })
  = do { Located Name
tycon' <- Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn Located RdrName
Located (IdP GhcPs)
tycon
       ; let kvs :: [Located RdrName]
kvs = HsDataDefn GhcPs -> [Located RdrName]
extractDataDefnKindVars HsDataDefn GhcPs
defn
             doc :: HsDocContext
doc = Located RdrName -> HsDocContext
TyDataCtx Located RdrName
Located (IdP GhcPs)
tycon
       ; String -> SDoc -> TcRn ()
traceRn String
"rntycl-data" (Located RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr Located RdrName
Located (IdP GhcPs)
tycon SDoc -> SDoc -> SDoc
<+> [Located RdrName] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Located RdrName]
kvs)
       ; HsDocContext
-> Maybe Any
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
-> TcM (TyClDecl GhcRn, FreeVars)
forall a b.
HsDocContext
-> Maybe a
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindHsQTyVars HsDocContext
doc Maybe Any
forall a. Maybe a
Nothing [Located RdrName]
kvs LHsQTyVars GhcPs
tyvars ((LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
 -> TcM (TyClDecl GhcRn, FreeVars))
-> (LHsQTyVars GhcRn -> Bool -> TcM (TyClDecl GhcRn, FreeVars))
-> TcM (TyClDecl GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ LHsQTyVars GhcRn
tyvars' Bool
no_rhs_kvs ->
    do { (HsDataDefn GhcRn
defn', FreeVars
fvs) <- HsDocContext
-> HsDataDefn GhcPs -> RnM (HsDataDefn GhcRn, FreeVars)
rnDataDefn HsDocContext
doc HsDataDefn GhcPs
defn
       ; Bool
cusk <- LHsQTyVars GhcRn
-> NewOrData -> Bool -> Maybe (LHsType GhcPs) -> TcRn Bool
forall pass pass'.
LHsQTyVars pass
-> NewOrData -> Bool -> Maybe (LHsKind pass') -> TcRn Bool
data_decl_has_cusk LHsQTyVars GhcRn
tyvars' NewOrData
new_or_data Bool
no_rhs_kvs Maybe (LHsType GhcPs)
kind_sig
       ; let rn_info :: DataDeclRn
rn_info = DataDeclRn :: Bool -> FreeVars -> DataDeclRn
DataDeclRn { tcdDataCusk :: Bool
tcdDataCusk = Bool
cusk
                                  , tcdFVs :: FreeVars
tcdFVs      = FreeVars
fvs }
       ; String -> SDoc -> TcRn ()
traceRn String
"rndata" (Located RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr Located RdrName
Located (IdP GhcPs)
tycon SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
cusk SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
no_rhs_kvs)
       ; (TyClDecl GhcRn, FreeVars) -> TcM (TyClDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (DataDecl :: forall pass.
XDataDecl pass
-> Located (IdP pass)
-> LHsQTyVars pass
-> LexicalFixity
-> HsDataDefn pass
-> TyClDecl pass
DataDecl { tcdLName :: Located (IdP GhcRn)
tcdLName    = Located Name
Located (IdP GhcRn)
tycon'
                          , tcdTyVars :: LHsQTyVars GhcRn
tcdTyVars   = LHsQTyVars GhcRn
tyvars'
                          , tcdFixity :: LexicalFixity
tcdFixity   = LexicalFixity
fixity
                          , tcdDataDefn :: HsDataDefn GhcRn
tcdDataDefn = HsDataDefn GhcRn
defn'
                          , tcdDExt :: XDataDecl GhcRn
tcdDExt     = XDataDecl GhcRn
DataDeclRn
rn_info }, FreeVars
fvs) } }

rnTyClDecl (ClassDecl { tcdCtxt :: forall pass. TyClDecl pass -> LHsContext pass
tcdCtxt = LHsContext GhcPs
context, tcdLName :: forall pass. TyClDecl pass -> Located (IdP pass)
tcdLName = Located (IdP 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]
tcdDocs = [LDocDecl]
docs})
  = do  { Located Name
lcls' <- Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn Located RdrName
Located (IdP GhcPs)
lcls
        ; let cls' :: Name
cls' = Located Name -> Name
forall l e. GenLocated l e -> e
unLoc Located Name
lcls'
              kvs :: [a]
kvs = []  -- No scoped kind vars except those in
                        -- kind signatures on the tyvars

        -- Tyvars scope over superclass context and method signatures
        ; ((LHsQTyVars GhcRn
tyvars', LHsContext GhcRn
context', [Located (FunDep (Located Name))]
fds', [LFamilyDecl GhcRn]
ats'), FreeVars
stuff_fvs)
            <- HsDocContext
-> Maybe Any
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn
    -> Bool
    -> RnM
         ((LHsQTyVars GhcRn, LHsContext GhcRn,
           [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
          FreeVars))
-> RnM
     ((LHsQTyVars GhcRn, LHsContext GhcRn,
       [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
      FreeVars)
forall a b.
HsDocContext
-> Maybe a
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindHsQTyVars HsDocContext
cls_doc Maybe Any
forall a. Maybe a
Nothing [Located RdrName]
forall a. [a]
kvs LHsQTyVars GhcPs
tyvars ((LHsQTyVars GhcRn
  -> Bool
  -> RnM
       ((LHsQTyVars GhcRn, LHsContext GhcRn,
         [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
        FreeVars))
 -> RnM
      ((LHsQTyVars GhcRn, LHsContext GhcRn,
        [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
       FreeVars))
-> (LHsQTyVars GhcRn
    -> Bool
    -> RnM
         ((LHsQTyVars GhcRn, LHsContext GhcRn,
           [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
          FreeVars))
-> RnM
     ((LHsQTyVars GhcRn, LHsContext GhcRn,
       [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
      FreeVars)
forall a b. (a -> b) -> a -> b
$ \ LHsQTyVars GhcRn
tyvars' Bool
_ -> do
                  -- Checks for distinct tyvars
             { (LHsContext GhcRn
context', FreeVars
cxt_fvs) <- HsDocContext
-> LHsContext GhcPs -> RnM (LHsContext GhcRn, FreeVars)
rnContext HsDocContext
cls_doc LHsContext GhcPs
context
             ; [Located (FunDep (Located Name))]
fds'  <- [LHsFunDep GhcPs] -> RnM [LHsFunDep GhcRn]
rnFds [LHsFunDep GhcPs]
fds
                         -- The fundeps have no free variables
             ; ([LFamilyDecl GhcRn]
ats', FreeVars
fv_ats) <- Name -> [LFamilyDecl GhcPs] -> RnM ([LFamilyDecl GhcRn], FreeVars)
rnATDecls Name
cls' [LFamilyDecl GhcPs]
ats
             ; let fvs :: FreeVars
fvs = FreeVars
cxt_fvs     FreeVars -> FreeVars -> FreeVars
`plusFV`
                         FreeVars
fv_ats
             ; ((LHsQTyVars GhcRn, LHsContext GhcRn,
  [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
 FreeVars)
-> RnM
     ((LHsQTyVars GhcRn, LHsContext GhcRn,
       [Located (FunDep (Located Name))], [LFamilyDecl GhcRn]),
      FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ((LHsQTyVars GhcRn
tyvars', LHsContext GhcRn
context', [Located (FunDep (Located Name))]
fds', [LFamilyDecl GhcRn]
ats'), FreeVars
fvs) }

        ; ([Located (TyFamInstDecl GhcRn)]
at_defs', FreeVars
fv_at_defs) <- (TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars))
-> [LTyFamInstDecl GhcPs]
-> RnM ([Located (TyFamInstDecl GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList (Name -> TyFamInstDecl GhcPs -> RnM (TyFamInstDecl GhcRn, FreeVars)
rnTyFamDefltDecl Name
cls') [LTyFamInstDecl GhcPs]
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 :: [Located RdrName]
sig_rdr_names_w_locs =
                [Located RdrName
op | L SrcSpan
_ (ClassOpSig XClassOpSig GhcPs
_ Bool
False [Located (IdP GhcPs)]
ops LHsSigType GhcPs
_) <- [LSig GhcPs]
sigs
                    , Located RdrName
op <- [Located RdrName]
[Located (IdP GhcPs)]
ops]
        ; [Located RdrName] -> TcRn ()
checkDupRdrNames [Located RdrName]
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.
        ; (LHsBinds GhcRn
mbinds', [LSig GhcRn]
sigs', FreeVars
meth_fvs)
            <- Bool
-> Name
-> [Name]
-> LHsBinds GhcPs
-> [LSig GhcPs]
-> RnM (LHsBinds GhcRn, [LSig GhcRn], FreeVars)
rnMethodBinds Bool
True Name
cls' (LHsQTyVars GhcRn -> [Name]
hsAllLTyVarNames LHsQTyVars GhcRn
tyvars') LHsBinds GhcPs
mbinds [LSig GhcPs]
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

  -- Haddock docs
        ; [LDocDecl]
docs' <- (LDocDecl -> IOEnv (Env TcGblEnv TcLclEnv) LDocDecl)
-> [LDocDecl] -> IOEnv (Env TcGblEnv TcLclEnv) [LDocDecl]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((DocDecl -> TcM DocDecl)
-> LDocDecl -> IOEnv (Env TcGblEnv TcLclEnv) LDocDecl
forall a b. (a -> TcM b) -> Located a -> TcM (Located b)
wrapLocM DocDecl -> TcM DocDecl
rnDocDecl) [LDocDecl]
docs

        ; let all_fvs :: FreeVars
all_fvs = FreeVars
meth_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
stuff_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_at_defs
        ; (TyClDecl GhcRn, FreeVars) -> TcM (TyClDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (ClassDecl :: forall pass.
XClassDecl pass
-> LHsContext pass
-> Located (IdP pass)
-> LHsQTyVars pass
-> LexicalFixity
-> [LHsFunDep pass]
-> [LSig pass]
-> LHsBinds pass
-> [LFamilyDecl pass]
-> [LTyFamDefltDecl pass]
-> [LDocDecl]
-> TyClDecl pass
ClassDecl { tcdCtxt :: LHsContext GhcRn
tcdCtxt = LHsContext GhcRn
context', tcdLName :: Located (IdP GhcRn)
tcdLName = Located Name
Located (IdP GhcRn)
lcls',
                              tcdTyVars :: LHsQTyVars GhcRn
tcdTyVars = LHsQTyVars GhcRn
tyvars', tcdFixity :: LexicalFixity
tcdFixity = LexicalFixity
fixity,
                              tcdFDs :: [LHsFunDep GhcRn]
tcdFDs = [Located (FunDep (Located Name))]
[LHsFunDep GhcRn]
fds', tcdSigs :: [LSig GhcRn]
tcdSigs = [LSig GhcRn]
sigs',
                              tcdMeths :: LHsBinds GhcRn
tcdMeths = LHsBinds GhcRn
mbinds', tcdATs :: [LFamilyDecl GhcRn]
tcdATs = [LFamilyDecl GhcRn]
ats', tcdATDefs :: [Located (TyFamInstDecl GhcRn)]
tcdATDefs = [Located (TyFamInstDecl GhcRn)]
at_defs',
                              tcdDocs :: [LDocDecl]
tcdDocs = [LDocDecl]
docs', tcdCExt :: XClassDecl GhcRn
tcdCExt = FreeVars
XClassDecl GhcRn
all_fvs },
                  FreeVars
all_fvs ) }
  where
    cls_doc :: HsDocContext
cls_doc  = Located RdrName -> HsDocContext
ClassDeclCtx Located RdrName
Located (IdP GhcPs)
lcls

-- Does the data type declaration include a CUSK?
data_decl_has_cusk :: LHsQTyVars pass -> NewOrData -> Bool -> Maybe (LHsKind pass') -> RnM Bool
data_decl_has_cusk :: forall pass pass'.
LHsQTyVars pass
-> NewOrData -> Bool -> Maybe (LHsKind pass') -> TcRn Bool
data_decl_has_cusk LHsQTyVars pass
tyvars NewOrData
new_or_data Bool
no_rhs_kvs Maybe (LHsKind pass')
kind_sig = do
  { -- See Note [Unlifted Newtypes and CUSKs], and for a broader
    -- picture, see Note [Implementation of UnliftedNewtypes].
  ; Bool
unlifted_newtypes <- Extension -> TcRn Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.UnliftedNewtypes
  ; let non_cusk_newtype :: Bool
non_cusk_newtype
          | NewOrData
NewType <- NewOrData
new_or_data =
              Bool
unlifted_newtypes Bool -> Bool -> Bool
&& Maybe (LHsKind pass') -> Bool
forall a. Maybe a -> Bool
isNothing Maybe (LHsKind pass')
kind_sig
          | Bool
otherwise = Bool
False
    -- See Note [CUSKs: complete user-supplied kind signatures] in GHC.Hs.Decls
  ; Bool -> TcRn Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> TcRn Bool) -> Bool -> TcRn Bool
forall a b. (a -> b) -> a -> b
$ LHsQTyVars pass -> Bool
forall pass. LHsQTyVars pass -> Bool
hsTvbAllKinded LHsQTyVars pass
tyvars Bool -> Bool -> Bool
&& Bool
no_rhs_kvs Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
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_ND :: forall pass. HsDataDefn pass -> NewOrData
dd_ND = NewOrData
new_or_data, dd_cType :: forall pass. HsDataDefn pass -> Maybe (Located CType)
dd_cType = Maybe (Located CType)
cType
                           , dd_ctxt :: forall pass. HsDataDefn pass -> LHsContext pass
dd_ctxt = LHsContext GhcPs
context, dd_cons :: forall pass. HsDataDefn pass -> [LConDecl pass]
dd_cons = [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  { Bool -> SDoc -> TcRn ()
checkTc (Bool
h98_style Bool -> Bool -> Bool
|| [LHsType GhcPs] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (LHsContext GhcPs -> [LHsType GhcPs]
forall l e. GenLocated l e -> e
unLoc LHsContext GhcPs
context))
                  (HsDocContext -> SDoc
badGadtStupidTheta HsDocContext
doc)

        ; (Maybe (LHsType GhcRn)
m_sig', FreeVars
sig_fvs) <- case Maybe (LHsType GhcPs)
m_sig of
             Just LHsType GhcPs
sig -> (LHsType GhcRn -> Maybe (LHsType GhcRn))
-> (LHsType GhcRn, FreeVars) -> (Maybe (LHsType GhcRn), FreeVars)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first LHsType GhcRn -> Maybe (LHsType GhcRn)
forall a. a -> Maybe a
Just ((LHsType GhcRn, FreeVars) -> (Maybe (LHsType GhcRn), FreeVars))
-> RnM (LHsType GhcRn, FreeVars)
-> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (LHsType 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 (LHsType GhcRn), FreeVars)
-> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (LHsType GhcRn), FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (LHsType GhcRn)
forall a. Maybe a
Nothing, FreeVars
emptyFVs)
        ; (LHsContext GhcRn
context', FreeVars
fvs1) <- HsDocContext
-> LHsContext GhcPs -> RnM (LHsContext GhcRn, FreeVars)
rnContext HsDocContext
doc LHsContext GhcPs
context
        ; (GenLocated SrcSpan [LHsDerivingClause GhcRn]
derivs',  FreeVars
fvs3) <- HsDeriving GhcPs
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpan [LHsDerivingClause GhcRn], FreeVars)
rn_derivs HsDeriving GhcPs
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 :: RnM ([LConDecl GhcRn], FreeVars)
-> RnM ([LConDecl GhcRn], FreeVars)
zap_lcl_env | Bool
h98_style = \ RnM ([LConDecl GhcRn], FreeVars)
thing -> RnM ([LConDecl GhcRn], FreeVars)
thing
                            | Bool
otherwise = LocalRdrEnv
-> RnM ([LConDecl GhcRn], FreeVars)
-> RnM ([LConDecl GhcRn], FreeVars)
forall a. LocalRdrEnv -> RnM a -> RnM a
setLocalRdrEnv LocalRdrEnv
emptyLocalRdrEnv }
        ; ([LConDecl GhcRn]
condecls', FreeVars
con_fvs) <- RnM ([LConDecl GhcRn], FreeVars)
-> RnM ([LConDecl GhcRn], FreeVars)
zap_lcl_env (RnM ([LConDecl GhcRn], FreeVars)
 -> RnM ([LConDecl GhcRn], FreeVars))
-> RnM ([LConDecl GhcRn], FreeVars)
-> RnM ([LConDecl GhcRn], FreeVars)
forall a b. (a -> b) -> a -> b
$ [LConDecl GhcPs] -> RnM ([LConDecl GhcRn], FreeVars)
rnConDecls [LConDecl GhcPs]
condecls
           -- No need to check for duplicate constructor decls
           -- since that is done by GHC.Rename.Names.extendGlobalRdrEnvRn

        ; let all_fvs :: FreeVars
all_fvs = FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3 FreeVars -> FreeVars -> FreeVars
`plusFV`
                        FreeVars
con_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
sig_fvs
        ; (HsDataDefn GhcRn, FreeVars) -> RnM (HsDataDefn GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ( HsDataDefn :: forall pass.
XCHsDataDefn pass
-> NewOrData
-> LHsContext pass
-> Maybe (Located CType)
-> Maybe (LHsKind pass)
-> [LConDecl pass]
-> HsDeriving pass
-> HsDataDefn pass
HsDataDefn { dd_ext :: XCHsDataDefn GhcRn
dd_ext = NoExtField
XCHsDataDefn GhcRn
noExtField
                              , dd_ND :: NewOrData
dd_ND = NewOrData
new_or_data, dd_cType :: Maybe (Located CType)
dd_cType = Maybe (Located CType)
cType
                              , dd_ctxt :: LHsContext GhcRn
dd_ctxt = LHsContext GhcRn
context', dd_kindSig :: Maybe (LHsType GhcRn)
dd_kindSig = Maybe (LHsType GhcRn)
m_sig'
                              , dd_cons :: [LConDecl GhcRn]
dd_cons = [LConDecl GhcRn]
condecls'
                              , dd_derivs :: GenLocated SrcSpan [LHsDerivingClause GhcRn]
dd_derivs = GenLocated SrcSpan [LHsDerivingClause GhcRn]
derivs' }
                 , FreeVars
all_fvs )
        }
  where
    h98_style :: Bool
h98_style = case [LConDecl GhcPs]
condecls of  -- Note [Stupid theta]
                     (L SrcSpan
_ (ConDeclGADT {}))                    : [LConDecl GhcPs]
_ -> Bool
False
                     [LConDecl GhcPs]
_                                             -> Bool
True

    rn_derivs :: HsDeriving GhcPs
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpan [LHsDerivingClause GhcRn], FreeVars)
rn_derivs (L SrcSpan
loc [LHsDerivingClause GhcPs]
ds)
      = do { Bool
deriv_strats_ok <- Extension -> TcRn Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.DerivingStrategies
           ; Bool -> SDoc -> TcRn ()
failIfTc ([LHsDerivingClause GhcPs] -> Int -> Bool
forall a. [a] -> Int -> Bool
lengthExceeds [LHsDerivingClause GhcPs]
ds Int
1 Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
deriv_strats_ok)
               SDoc
multipleDerivClausesErr
           ; ([LHsDerivingClause GhcRn]
ds', FreeVars
fvs) <- (LHsDerivingClause GhcPs
 -> RnM (LHsDerivingClause GhcRn, FreeVars))
-> [LHsDerivingClause GhcPs]
-> RnM ([LHsDerivingClause GhcRn], FreeVars)
forall a b. (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
mapFvRn (HsDocContext
-> LHsDerivingClause GhcPs
-> RnM (LHsDerivingClause GhcRn, FreeVars)
rnLHsDerivingClause HsDocContext
doc) [LHsDerivingClause GhcPs]
ds
           ; (GenLocated SrcSpan [LHsDerivingClause GhcRn], FreeVars)
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpan [LHsDerivingClause GhcRn], FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (SrcSpan
-> [LHsDerivingClause GhcRn]
-> GenLocated SrcSpan [LHsDerivingClause GhcRn]
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc [LHsDerivingClause GhcRn]
ds', FreeVars
fvs) }

warnNoDerivStrat :: Maybe (LDerivStrategy GhcRn)
                 -> SrcSpan
                 -> RnM ()
warnNoDerivStrat :: Maybe (LDerivStrategy GhcRn) -> SrcSpan -> TcRn ()
warnNoDerivStrat Maybe (LDerivStrategy GhcRn)
mds SrcSpan
loc
  = do { DynFlags
dyn_flags <- IOEnv (Env TcGblEnv TcLclEnv) DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (WarningFlag -> DynFlags -> Bool
wopt WarningFlag
Opt_WarnMissingDerivingStrategies DynFlags
dyn_flags) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
           case Maybe (LDerivStrategy GhcRn)
mds of
             Maybe (LDerivStrategy GhcRn)
Nothing -> WarnReason -> SrcSpan -> SDoc -> TcRn ()
addWarnAt
               (WarningFlag -> WarnReason
Reason WarningFlag
Opt_WarnMissingDerivingStrategies)
               SrcSpan
loc
               (if Extension -> DynFlags -> Bool
xopt Extension
LangExt.DerivingStrategies DynFlags
dyn_flags
                 then SDoc
no_strat_warning
                 else SDoc
no_strat_warning SDoc -> SDoc -> SDoc
$+$ SDoc
deriv_strat_nenabled
               )
             Maybe (LDerivStrategy GhcRn)
_ -> () -> TcRn ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
       }
  where
    no_strat_warning :: SDoc
    no_strat_warning :: SDoc
no_strat_warning = String -> SDoc
text String
"No deriving strategy specified. Did you want stock"
                       SDoc -> SDoc -> SDoc
<> String -> SDoc
text String
", newtype, or anyclass?"
    deriv_strat_nenabled :: SDoc
    deriv_strat_nenabled :: SDoc
deriv_strat_nenabled = String -> SDoc
text String
"Use DerivingStrategies to specify a strategy."

rnLHsDerivingClause :: HsDocContext -> LHsDerivingClause GhcPs
                    -> RnM (LHsDerivingClause GhcRn, FreeVars)
rnLHsDerivingClause :: HsDocContext
-> LHsDerivingClause GhcPs
-> RnM (LHsDerivingClause GhcRn, FreeVars)
rnLHsDerivingClause HsDocContext
doc
                (L SrcSpan
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 -> Located [LHsSigType pass]
deriv_clause_tys = L SrcSpan
loc' [LHsSigType GhcPs]
dct }))
  = do { (Maybe (LDerivStrategy GhcRn)
dcs', [LHsSigType GhcRn]
dct', FreeVars
fvs)
           <- HsDocContext
-> Maybe (LDerivStrategy GhcPs)
-> RnM ([LHsSigType GhcRn], FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), [LHsSigType 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 ([LHsSigType GhcRn], FreeVars)
 -> RnM
      (Maybe (LDerivStrategy GhcRn), [LHsSigType GhcRn], FreeVars))
-> RnM ([LHsSigType GhcRn], FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), [LHsSigType GhcRn], FreeVars)
forall a b. (a -> b) -> a -> b
$ (LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars))
-> [LHsSigType GhcPs] -> RnM ([LHsSigType GhcRn], FreeVars)
forall a b. (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
mapFvRn LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
rn_clause_pred [LHsSigType GhcPs]
dct
       ; Maybe (LDerivStrategy GhcRn) -> SrcSpan -> TcRn ()
warnNoDerivStrat Maybe (LDerivStrategy GhcRn)
dcs' SrcSpan
loc
       ; (LHsDerivingClause GhcRn, FreeVars)
-> RnM (LHsDerivingClause GhcRn, FreeVars)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ( SrcSpan -> HsDerivingClause GhcRn -> LHsDerivingClause GhcRn
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc (HsDerivingClause :: forall pass.
XCHsDerivingClause pass
-> Maybe (LDerivStrategy pass)
-> Located [LHsSigType pass]
-> HsDerivingClause pass
HsDerivingClause { deriv_clause_ext :: XCHsDerivingClause GhcRn
deriv_clause_ext = XCHsDerivingClause GhcPs
XCHsDerivingClause GhcRn
noExtField
                                        , deriv_clause_strategy :: Maybe (LDerivStrategy GhcRn)
deriv_clause_strategy = Maybe (LDerivStrategy GhcRn)
dcs'
                                        , deriv_clause_tys :: Located [LHsSigType GhcRn]
deriv_clause_tys = SrcSpan -> [LHsSigType GhcRn] -> Located [LHsSigType GhcRn]
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc' [LHsSigType GhcRn]
dct' })
              , FreeVars
fvs ) }
  where
    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
      let inf_err :: Maybe SDoc
inf_err = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (String -> SDoc
text String
"Inferred type variables are not allowed")
      HsDocContext -> Maybe SDoc -> LHsSigType GhcPs -> TcRn ()
checkInferredVars HsDocContext
doc Maybe SDoc
inf_err LHsSigType GhcPs
pred_ty
      ret :: (LHsSigType GhcRn, FreeVars)
ret@(LHsSigType GhcRn
pred_ty', FreeVars
_) <- 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.
      HsDocContext -> SDoc -> LHsType GhcRn -> TcRn ()
addNoNestedForallsContextsErr HsDocContext
doc (String -> SDoc
text String
"Derived class type")
        (LHsSigType GhcRn -> LHsType GhcRn
forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p)
getLHsInstDeclHead LHsSigType GhcRn
pred_ty')
      (LHsSigType GhcRn, FreeVars) -> RnM (LHsSigType GhcRn, FreeVars)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LHsSigType GhcRn, FreeVars)
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 (LDerivStrategy GhcRn)
-> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
forall ds. ds -> RnM (ds, a, FreeVars)
boring_case Maybe (LDerivStrategy GhcRn)
forall a. Maybe a
Nothing
      Just (L SrcSpan
loc DerivStrategy GhcPs
ds) ->
        SrcSpan
-> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
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
          (DerivStrategy GhcRn
ds', a
thing, FreeVars
fvs) <- DerivStrategy GhcPs -> RnM (DerivStrategy GhcRn, a, FreeVars)
rn_deriv_strat DerivStrategy GhcPs
ds
          (Maybe (LDerivStrategy GhcRn), a, FreeVars)
-> RnM (Maybe (LDerivStrategy GhcRn), a, FreeVars)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LDerivStrategy GhcRn -> Maybe (LDerivStrategy GhcRn)
forall a. a -> Maybe a
Just (SrcSpan -> DerivStrategy GhcRn -> LDerivStrategy GhcRn
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc DerivStrategy GhcRn
ds'), a
thing, FreeVars
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
$
        SDoc -> TcRn ()
forall a. SDoc -> TcM a
failWith (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ DerivStrategy GhcPs -> SDoc
illegalDerivStrategyErr DerivStrategy GhcPs
ds

      case DerivStrategy GhcPs
ds of
        DerivStrategy GhcPs
StockStrategy    -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
forall ds. ds -> RnM (ds, a, FreeVars)
boring_case DerivStrategy GhcRn
forall pass. DerivStrategy pass
StockStrategy
        DerivStrategy GhcPs
AnyclassStrategy -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
forall ds. ds -> RnM (ds, a, FreeVars)
boring_case DerivStrategy GhcRn
forall pass. DerivStrategy pass
AnyclassStrategy
        DerivStrategy GhcPs
NewtypeStrategy  -> DerivStrategy GhcRn -> RnM (DerivStrategy GhcRn, a, FreeVars)
forall ds. ds -> RnM (ds, a, FreeVars)
boring_case DerivStrategy GhcRn
forall pass. DerivStrategy pass
NewtypeStrategy
        ViaStrategy XViaStrategy GhcPs
via_ty ->
          do HsDocContext -> Maybe SDoc -> LHsSigType GhcPs -> TcRn ()
checkInferredVars HsDocContext
doc Maybe SDoc
inf_err XViaStrategy GhcPs
LHsSigType GhcPs
via_ty
             (LHsSigType GhcRn
via_ty', FreeVars
fvs1) <- HsDocContext
-> TypeOrKind
-> LHsSigType GhcPs
-> RnM (LHsSigType GhcRn, FreeVars)
rnHsSigType HsDocContext
doc TypeOrKind
TypeLevel XViaStrategy GhcPs
LHsSigType GhcPs
via_ty
             let HsIB { hsib_ext :: forall pass thing. HsImplicitBndrs pass thing -> XHsIB pass thing
hsib_ext  = XHsIB GhcRn (LHsType GhcRn)
via_imp_tvs
                      , hsib_body :: forall pass thing. HsImplicitBndrs pass thing -> thing
hsib_body = LHsType GhcRn
via_body } = LHsSigType GhcRn
via_ty'
                 (Maybe [LHsTyVarBndr Specificity GhcRn]
via_exp_tv_bndrs, LHsType GhcRn
via_rho) = LHsType GhcRn
-> (Maybe [LHsTyVarBndr Specificity GhcRn], LHsType GhcRn)
forall pass.
LHsType pass
-> (Maybe [LHsTyVarBndr Specificity pass], LHsType pass)
splitLHsForAllTyInvis_KP LHsType GhcRn
via_body
                 via_exp_tvs :: [Name]
via_exp_tvs = [Name]
-> ([LHsTyVarBndr Specificity GhcRn] -> [Name])
-> Maybe [LHsTyVarBndr Specificity GhcRn]
-> [Name]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] [LHsTyVarBndr Specificity GhcRn] -> [Name]
forall flag (p :: Pass).
[LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]
hsLTyVarNames Maybe [LHsTyVarBndr Specificity GhcRn]
via_exp_tv_bndrs
                 via_tvs :: [Name]
via_tvs = [Name]
XHsIB GhcRn (LHsType GhcRn)
via_imp_tvs [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ [Name]
via_exp_tvs
             -- 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.
             HsDocContext -> SDoc -> LHsType GhcRn -> TcRn ()
addNoNestedForallsContextsErr HsDocContext
doc
               (SDoc -> SDoc
quotes (String -> SDoc
text String
"via") SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"type") LHsType GhcRn
via_rho
             (a
thing, FreeVars
fvs2) <- [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
extendTyVarEnvFVRn [Name]
via_tvs RnM (a, FreeVars)
thing_inside
             (DerivStrategy GhcRn, a, FreeVars)
-> RnM (DerivStrategy GhcRn, a, FreeVars)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (XViaStrategy GhcRn -> DerivStrategy GhcRn
forall pass. XViaStrategy pass -> DerivStrategy pass
ViaStrategy XViaStrategy GhcRn
LHsSigType GhcRn
via_ty', a
thing, FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2)

    inf_err :: Maybe SDoc
inf_err = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (String -> SDoc
text String
"Inferred type variables are not allowed")

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

badGadtStupidTheta :: HsDocContext -> SDoc
badGadtStupidTheta :: HsDocContext -> SDoc
badGadtStupidTheta HsDocContext
_
  = [SDoc] -> SDoc
vcat [String -> SDoc
text String
"No context is allowed on a GADT-style data declaration",
          String -> SDoc
text String
"(You can put a context on each constructor, though.)"]

illegalDerivStrategyErr :: DerivStrategy GhcPs -> SDoc
illegalDerivStrategyErr :: DerivStrategy GhcPs -> SDoc
illegalDerivStrategyErr DerivStrategy GhcPs
ds
  = [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Illegal deriving strategy" SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<+> DerivStrategy GhcPs -> SDoc
forall a. DerivStrategy a -> SDoc
derivStrategyName DerivStrategy GhcPs
ds
         , String -> SDoc
text String
enableStrategy ]

  where
    enableStrategy :: String
    enableStrategy :: String
enableStrategy
      | ViaStrategy{} <- DerivStrategy GhcPs
ds
      = String
"Use DerivingVia to enable this extension"
      | Bool
otherwise
      = String
"Use DerivingStrategies to enable this extension"

multipleDerivClausesErr :: SDoc
multipleDerivClausesErr :: SDoc
multipleDerivClausesErr
  = [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Illegal use of multiple, consecutive deriving clauses"
         , String -> SDoc
text String
"Use DerivingStrategies to allow this" ]

rnFamDecl :: Maybe Name -- Just cls => this FamilyDecl is nested
                        --             inside an *class decl* for cls
                        --             used for associated types
          -> FamilyDecl GhcPs
          -> RnM (FamilyDecl GhcRn, FreeVars)
rnFamDecl :: Maybe Name -> FamilyDecl GhcPs -> RnM (FamilyDecl GhcRn, FreeVars)
rnFamDecl Maybe Name
mb_cls (FamilyDecl { fdLName :: forall pass. FamilyDecl pass -> Located (IdP pass)
fdLName = Located (IdP GhcPs)
tycon, fdTyVars :: forall pass. FamilyDecl pass -> LHsQTyVars pass
fdTyVars = LHsQTyVars GhcPs
tyvars
                             , 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 { Located Name
tycon' <- Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn Located RdrName
Located (IdP GhcPs)
tycon
       ; ((LHsQTyVars GhcRn
tyvars', Located (FamilyResultSig GhcRn)
res_sig', Maybe (LInjectivityAnn GhcRn)
injectivity'), FreeVars
fv1) <-
            HsDocContext
-> Maybe Name
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn
    -> Bool
    -> RnM
         ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
           Maybe (LInjectivityAnn GhcRn)),
          FreeVars))
-> RnM
     ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
       Maybe (LInjectivityAnn GhcRn)),
      FreeVars)
forall a b.
HsDocContext
-> Maybe a
-> [Located RdrName]
-> LHsQTyVars GhcPs
-> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars))
-> RnM (b, FreeVars)
bindHsQTyVars HsDocContext
doc Maybe Name
mb_cls [Located RdrName]
kvs LHsQTyVars GhcPs
tyvars ((LHsQTyVars GhcRn
  -> Bool
  -> RnM
       ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
         Maybe (LInjectivityAnn GhcRn)),
        FreeVars))
 -> RnM
      ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
        Maybe (LInjectivityAnn GhcRn)),
       FreeVars))
-> (LHsQTyVars GhcRn
    -> Bool
    -> RnM
         ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
           Maybe (LInjectivityAnn GhcRn)),
          FreeVars))
-> RnM
     ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
       Maybe (LInjectivityAnn GhcRn)),
      FreeVars)
forall a b. (a -> b) -> a -> b
$ \ LHsQTyVars GhcRn
tyvars' Bool
_ ->
            do { let rn_sig :: FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
rn_sig = HsDocContext
-> FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
rnFamResultSig HsDocContext
doc
               ; (Located (FamilyResultSig GhcRn)
res_sig', FreeVars
fv_kind) <- (FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars))
-> LFamilyResultSig GhcPs
-> TcM (Located (FamilyResultSig GhcRn), FreeVars)
forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM FamilyResultSig GhcPs -> RnM (FamilyResultSig GhcRn, FreeVars)
rn_sig LFamilyResultSig GhcPs
res_sig
               ; Maybe (LInjectivityAnn GhcRn)
injectivity' <- (LInjectivityAnn GhcPs
 -> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn))
-> Maybe (LInjectivityAnn GhcPs)
-> IOEnv (Env TcGblEnv TcLclEnv) (Maybe (LInjectivityAnn GhcRn))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (LHsQTyVars GhcRn
-> Located (FamilyResultSig GhcRn)
-> LInjectivityAnn GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
rnInjectivityAnn LHsQTyVars GhcRn
tyvars' Located (FamilyResultSig GhcRn)
res_sig')
                                          Maybe (LInjectivityAnn GhcPs)
injectivity
               ; ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
  Maybe (LInjectivityAnn GhcRn)),
 FreeVars)
-> RnM
     ((LHsQTyVars GhcRn, Located (FamilyResultSig GhcRn),
       Maybe (LInjectivityAnn GhcRn)),
      FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ( (LHsQTyVars GhcRn
tyvars', Located (FamilyResultSig GhcRn)
res_sig', Maybe (LInjectivityAnn GhcRn)
injectivity') , FreeVars
fv_kind ) }
       ; (FamilyInfo GhcRn
info', FreeVars
fv2) <- FamilyInfo GhcPs -> RnM (FamilyInfo GhcRn, FreeVars)
rn_info FamilyInfo GhcPs
info
       ; (FamilyDecl GhcRn, FreeVars) -> RnM (FamilyDecl GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (FamilyDecl :: forall pass.
XCFamilyDecl pass
-> FamilyInfo pass
-> Located (IdP pass)
-> LHsQTyVars pass
-> LexicalFixity
-> LFamilyResultSig pass
-> Maybe (LInjectivityAnn pass)
-> FamilyDecl pass
FamilyDecl { fdExt :: XCFamilyDecl GhcRn
fdExt = NoExtField
XCFamilyDecl GhcRn
noExtField
                            , fdLName :: Located (IdP GhcRn)
fdLName = Located Name
Located (IdP GhcRn)
tycon', fdTyVars :: LHsQTyVars GhcRn
fdTyVars = LHsQTyVars GhcRn
tyvars'
                            , fdFixity :: LexicalFixity
fdFixity = LexicalFixity
fixity
                            , fdInfo :: FamilyInfo GhcRn
fdInfo = FamilyInfo GhcRn
info', fdResultSig :: Located (FamilyResultSig GhcRn)
fdResultSig = Located (FamilyResultSig GhcRn)
res_sig'
                            , fdInjectivityAnn :: Maybe (LInjectivityAnn GhcRn)
fdInjectivityAnn = Maybe (LInjectivityAnn GhcRn)
injectivity' }
                , FreeVars
fv1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv2) }
  where
     doc :: HsDocContext
doc = Located RdrName -> HsDocContext
TyFamilyCtx Located RdrName
Located (IdP GhcPs)
tycon
     kvs :: [Located RdrName]
kvs = LFamilyResultSig GhcPs -> [Located RdrName]
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 { ([Located (TyFamInstEqn GhcRn)]
eqns', FreeVars
fvs)
                <- (TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars))
-> [LTyFamInstEqn GhcPs]
-> RnM ([Located (TyFamInstEqn GhcRn)], FreeVars)
forall a b.
(a -> RnM (b, FreeVars))
-> [Located a] -> RnM ([Located b], FreeVars)
rnList (AssocTyFamInfo
-> TyFamInstEqn GhcPs -> RnM (TyFamInstEqn GhcRn, FreeVars)
rnTyFamInstEqn (ClosedTyFamInfo -> AssocTyFamInfo
NonAssocTyFamEqn ClosedTyFamInfo
ClosedTyFam)) [LTyFamInstEqn GhcPs]
eqns
                                          -- no class context
            ; (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Located (TyFamInstEqn GhcRn)] -> FamilyInfo GhcRn
forall pass. Maybe [LTyFamInstEqn pass] -> FamilyInfo pass
ClosedTypeFamily ([Located (TyFamInstEqn GhcRn)]
-> Maybe [Located (TyFamInstEqn GhcRn)]
forall a. a -> Maybe a
Just [Located (TyFamInstEqn GhcRn)]
eqns'), FreeVars
fvs) }
     rn_info (ClosedTypeFamily Maybe [LTyFamInstEqn GhcPs]
Nothing)
       = (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Located (TyFamInstEqn GhcRn)] -> FamilyInfo GhcRn
forall pass. Maybe [LTyFamInstEqn pass] -> FamilyInfo pass
ClosedTypeFamily Maybe [Located (TyFamInstEqn GhcRn)]
forall a. Maybe a
Nothing, FreeVars
emptyFVs)
     rn_info FamilyInfo GhcPs
OpenTypeFamily = (FamilyInfo GhcRn, FreeVars) -> RnM (FamilyInfo GhcRn, FreeVars)
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 (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 (m :: * -> *) a. Monad m => a -> m a
return (XNoSig GhcRn -> FamilyResultSig GhcRn
forall pass. XNoSig pass -> FamilyResultSig pass
NoSig NoExtField
XNoSig GhcRn
noExtField, FreeVars
emptyFVs)
rnFamResultSig HsDocContext
doc (KindSig XCKindSig GhcPs
_ LHsType GhcPs
kind)
   = do { (LHsType GhcRn
rndKind, FreeVars
ftvs) <- HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
rnLHsKind HsDocContext
doc LHsType GhcPs
kind
        ;  (FamilyResultSig GhcRn, FreeVars)
-> RnM (FamilyResultSig GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XCKindSig GhcRn -> LHsType GhcRn -> FamilyResultSig GhcRn
forall pass. XCKindSig pass -> LHsKind pass -> FamilyResultSig pass
KindSig NoExtField
XCKindSig GhcRn
noExtField LHsType GhcRn
rndKind, FreeVars
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
          LocalRdrEnv
rdr_env <- RnM LocalRdrEnv
getLocalRdrEnv
       ;  let resName :: IdP GhcPs
resName = LHsTyVarBndr () GhcPs -> IdP GhcPs
forall flag (p :: Pass).
LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
hsLTyVarName LHsTyVarBndr () GhcPs
tvbndr
       ;  Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (RdrName
IdP GhcPs
resName RdrName -> LocalRdrEnv -> Bool
`elemLocalRdrEnv` LocalRdrEnv
rdr_env) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
          SrcSpan -> SDoc -> TcRn ()
addErrAt (LHsTyVarBndr () GhcPs -> SrcSpan
forall l e. GenLocated l e -> l
getLoc LHsTyVarBndr () GhcPs
tvbndr) (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$
                     ([SDoc] -> SDoc
hsep [ String -> SDoc
text String
"Type variable", SDoc -> SDoc
quotes (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
IdP GhcPs
resName) SDoc -> SDoc -> SDoc
<> SDoc
comma
                           , String -> SDoc
text String
"naming a type family result,"
                           ] SDoc -> SDoc -> SDoc
$$
                      String -> SDoc
text String
"shadows an already bound type variable")

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

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

-- | Rename injectivity annotation. Note that injectivity annotation is just the
-- part after the "|".  Everything that appears before it is renamed in
-- rnFamDecl.
rnInjectivityAnn :: LHsQTyVars GhcRn           -- ^ Type variables declared in
                                               --   type family head
                 -> LFamilyResultSig GhcRn     -- ^ Result signature
                 -> LInjectivityAnn GhcPs      -- ^ Injectivity annotation
                 -> RnM (LInjectivityAnn GhcRn)
rnInjectivityAnn :: LHsQTyVars GhcRn
-> Located (FamilyResultSig GhcRn)
-> LInjectivityAnn GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
rnInjectivityAnn LHsQTyVars GhcRn
tvBndrs (L SrcSpan
_ (TyVarSig XTyVarSig GhcRn
_ LHsTyVarBndr () GhcRn
resTv))
                 (L SrcSpan
srcSpan (InjectivityAnn Located (IdP GhcPs)
injFrom [Located (IdP GhcPs)]
injTo))
 = do
   { (injDecl' :: LInjectivityAnn GhcRn
injDecl'@(L SrcSpan
_ (InjectivityAnn Located (IdP GhcRn)
injFrom' [Located (IdP GhcRn)]
injTo')), Bool
noRnErrors)
          <- IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
-> TcRn (LInjectivityAnn GhcRn, Bool)
forall a. TcRn a -> TcRn (a, Bool)
askNoErrs (IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
 -> TcRn (LInjectivityAnn GhcRn, Bool))
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
-> TcRn (LInjectivityAnn GhcRn, Bool)
forall a b. (a -> b) -> a -> b
$
             [Name]
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
forall a. [Name] -> RnM a -> RnM a
bindLocalNames [LHsTyVarBndr () GhcRn -> IdP GhcRn
forall flag (p :: Pass).
LHsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
hsLTyVarName LHsTyVarBndr () GhcRn
resTv] (IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
 -> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn))
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn GhcRn)
-> IOEnv (Env TcGblEnv TcLclEnv) (LInjectivityAnn 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 {