{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}

-- | This module is used to perform a dependency analysis of top-level
-- function definitions, i.e. to find out which defintions are
-- (mutual) recursive. To this end, this module also provides
-- functions to compute, bound variables and variable occurrences.

module AsyncRattus.Plugin.Dependency (dependency, HasBV (..),printBinds) where


import GHC.Plugins
import GHC.Data.Bag
import GHC.Hs.Type


import GHC.Hs.Extension
import GHC.Hs.Expr
import GHC.Hs.Pat
import GHC.Hs.Binds

#if __GLASGOW_HASKELL__ >= 904
import GHC.Parser.Annotation
#else
import Language.Haskell.Syntax.Extension
import GHC.Parser.Annotation
#endif


import Data.Set (Set)
import qualified Data.Set as Set
import Data.Graph
import Data.Maybe
import Data.Either
import Prelude hiding ((<>))



-- | Compute the dependencies of a bag of bindings, returning a list
-- of the strongly-connected components.
dependency :: Bag (LHsBindLR GhcTc GhcTc) -> [SCC (LHsBindLR GhcTc GhcTc, Set Var)]
dependency :: Bag (LHsBindLR GhcTc GhcTc)
-> [SCC (LHsBindLR GhcTc GhcTc, Set Var)]
dependency Bag (LHsBindLR GhcTc GhcTc)
binds = ((GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)
 -> SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))
-> [(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
-> [SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
forall a b. (a -> b) -> [a] -> [b]
map (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)
-> SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)
forall vertex. vertex -> SCC vertex
AcyclicSCC [(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
noDeps [SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
-> [SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
-> [SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
forall a. [a] -> [a] -> [a]
++ [Maybe
   (SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))]
-> [SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
forall a. [Maybe a] -> [a]
catMaybes ((SCC
   (Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))
 -> Maybe
      (SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)))
-> [SCC
      (Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))]
-> [Maybe
      (SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))]
forall a b. (a -> b) -> [a] -> [b]
map SCC
  (Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))
-> Maybe
     (SCC (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))
forall {vertex}. SCC (Maybe vertex) -> Maybe (SCC vertex)
filterJust ([(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
  Name, [Name])]
-> [SCC
      (Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))]
forall key node. Ord key => [(node, key, [key])] -> [SCC node]
stronglyConnComp ([[(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
   Name, [Name])]]
-> [(Maybe
       (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
     Name, [Name])]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
   Name, [Name])]]
deps)))
  where ([[(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
   Name, [Name])]]
deps,[(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
noDeps) = [Either
   [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
     Name, [Name])]
   (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
-> ([[(Maybe
         (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
       Name, [Name])]],
    [(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)])
forall a b. [Either a b] -> ([a], [b])
partitionEithers ([Either
    [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
      Name, [Name])]
    (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
 -> ([[(Maybe
          (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
        Name, [Name])]],
     [(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]))
-> [Either
      [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
        Name, [Name])]
      (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
-> ([[(Maybe
         (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
       Name, [Name])]],
    [(GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)])
forall a b. (a -> b) -> a -> b
$ (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)
 -> Either
      [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
        Name, [Name])]
      (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var))
-> [GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)]
-> [Either
      [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
        Name, [Name])]
      (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
forall a b. (a -> b) -> [a] -> [b]
map GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)
-> Either
     [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
       Name, [Name])]
     (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)
forall l.
GenLocated l (HsBindLR GhcTc GhcTc)
-> Either
     [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
       [Name])]
     (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
mkDep ([GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)]
 -> [Either
       [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
         Name, [Name])]
       (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)])
-> [GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)]
-> [Either
      [(Maybe (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var),
        Name, [Name])]
      (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc), Set Var)]
forall a b. (a -> b) -> a -> b
$ Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc))
-> [GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)]
forall a. Bag a -> [a]
bagToList Bag (LHsBindLR GhcTc GhcTc)
Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc))
binds
        mkDep :: GenLocated l (HsBindLR GhcTc GhcTc) ->
                 Either [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name, [Name])]
                 (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
        mkDep :: forall l.
GenLocated l (HsBindLR GhcTc GhcTc)
-> Either
     [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
       [Name])]
     (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
mkDep GenLocated l (HsBindLR GhcTc GhcTc)
b =
          let dep :: [Name]
dep = (Var -> Name) -> [Var] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map Var -> Name
varName ([Var] -> [Name]) -> [Var] -> [Name]
forall a b. (a -> b) -> a -> b
$ Set Var -> [Var]
forall a. Set a -> [a]
Set.toList (GenLocated l (HsBindLR GhcTc GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV GenLocated l (HsBindLR GhcTc GhcTc)
b)
              vars :: Set Var
vars = GenLocated l (HsBindLR GhcTc GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV GenLocated l (HsBindLR GhcTc GhcTc)
b in
          case Set Var -> [Var]
forall a. Set a -> [a]
Set.toList Set Var
vars of
            (Var
v:[Var]
vs) -> [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
  [Name])]
-> Either
     [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
       [Name])]
     (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
forall a b. a -> Either a b
Left (((GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
-> Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
forall a. a -> Maybe a
Just (GenLocated l (HsBindLR GhcTc GhcTc)
b,Set Var
vars), Var -> Name
varName Var
v , [Name]
dep) (Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
 [Name])
-> [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
     [Name])]
-> [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
     [Name])]
forall a. a -> [a] -> [a]
: (Var
 -> (Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
     [Name]))
-> [Var]
-> [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
     [Name])]
forall a b. (a -> b) -> [a] -> [b]
map (\ Var
v' -> (Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
forall a. Maybe a
Nothing, Var -> Name
varName Var
v' , [Name]
dep)) [Var]
vs)
            [] -> (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
-> Either
     [(Maybe (GenLocated l (HsBindLR GhcTc GhcTc), Set Var), Name,
       [Name])]
     (GenLocated l (HsBindLR GhcTc GhcTc), Set Var)
forall a b. b -> Either a b
Right (GenLocated l (HsBindLR GhcTc GhcTc)
b,Set Var
vars)
        filterJust :: SCC (Maybe vertex) -> Maybe (SCC vertex)
filterJust (AcyclicSCC Maybe vertex
Nothing) = Maybe (SCC vertex)
forall a. Maybe a
Nothing -- this should not happen
        filterJust (AcyclicSCC (Just vertex
b)) = SCC vertex -> Maybe (SCC vertex)
forall a. a -> Maybe a
Just (vertex -> SCC vertex
forall vertex. vertex -> SCC vertex
AcyclicSCC vertex
b)
        filterJust (CyclicSCC [Maybe vertex]
bs) = SCC vertex -> Maybe (SCC vertex)
forall a. a -> Maybe a
Just ([vertex] -> SCC vertex
forall vertex. [vertex] -> SCC vertex
CyclicSCC ([Maybe vertex] -> [vertex]
forall a. [Maybe a] -> [a]
catMaybes [Maybe vertex]
bs))


printBinds :: SCC (GenLocated l (HsBindLR idL idR), b) -> m ()
printBinds (AcyclicSCC (GenLocated l (HsBindLR idL idR), b)
bind) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStr String
"acyclic bind: ") m () -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GenLocated l (HsBindLR idL idR) -> m ()
forall {idL} {l} {idR} {m :: * -> *} {l}.
(XRec idL (IdP idL) ~ GenLocated l (IdP idL),
 XXHsBindsLR idL idR ~ AbsBinds, MonadIO m, NamedThing (IdP idL)) =>
GenLocated l (HsBindLR idL idR) -> m ()
printBind ((GenLocated l (HsBindLR idL idR), b)
-> GenLocated l (HsBindLR idL idR)
forall a b. (a, b) -> a
fst (GenLocated l (HsBindLR idL idR), b)
bind) m () -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStrLn String
"") 
printBinds (CyclicSCC [(GenLocated l (HsBindLR idL idR), b)]
binds) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStr String
"cyclic binds: ") m () -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((GenLocated l (HsBindLR idL idR), b) -> m ())
-> [(GenLocated l (HsBindLR idL idR), b)] -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (GenLocated l (HsBindLR idL idR) -> m ()
forall {idL} {l} {idR} {m :: * -> *} {l}.
(XRec idL (IdP idL) ~ GenLocated l (IdP idL),
 XXHsBindsLR idL idR ~ AbsBinds, MonadIO m, NamedThing (IdP idL)) =>
GenLocated l (HsBindLR idL idR) -> m ()
printBind (GenLocated l (HsBindLR idL idR) -> m ())
-> ((GenLocated l (HsBindLR idL idR), b)
    -> GenLocated l (HsBindLR idL idR))
-> (GenLocated l (HsBindLR idL idR), b)
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenLocated l (HsBindLR idL idR), b)
-> GenLocated l (HsBindLR idL idR)
forall a b. (a, b) -> a
fst) [(GenLocated l (HsBindLR idL idR), b)]
binds m () -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStrLn String
"") 


printBind :: GenLocated l (HsBindLR idL idR) -> m ()
printBind (L l
_ FunBind{fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
fun_id = L l
_ IdP idL
name}) = 
  IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ String -> IO ()
putStr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ (IdP idL -> String
forall a. NamedThing a => a -> String
getOccString IdP idL
name String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ")
printBind (L l
_ (VarBind {var_id :: forall idL idR. HsBindLR idL idR -> IdP idL
var_id = IdP idL
name})) =   IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ String -> IO ()
putStr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ (IdP idL -> String
forall a. NamedThing a => a -> String
getOccString IdP idL
name String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ")
#if __GLASGOW_HASKELL__ < 904
printBind (L _ (AbsBinds {abs_exports = exp})) = 
#else
printBind (L l
_ (XHsBindsLR (AbsBinds {abs_exports :: AbsBinds -> [ABExport]
abs_exports = [ABExport]
exp}))) = 
#endif
  (ABExport -> m ()) -> [ABExport] -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ ABExport
e -> IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ String -> IO ()
putStr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ ((Var -> String
forall a. NamedThing a => a -> String
getOccString (Var -> String) -> Var -> String
forall a b. (a -> b) -> a -> b
$ ABExport -> Var
abe_poly ABExport
e)  String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ")) [ABExport]
exp
printBind GenLocated l (HsBindLR idL idR)
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- | Computes the variables that are bound by a given piece of syntax.

class HasBV a where
  getBV :: a -> Set Var

instance HasBV (HsBindLR GhcTc GhcTc) where
  getBV :: HsBindLR GhcTc GhcTc -> Set Var
getBV (FunBind{fun_id :: forall idL idR. HsBindLR idL idR -> LIdP idL
fun_id = L SrcSpanAnnN
_ Var
v}) = Var -> Set Var
forall a. a -> Set a
Set.singleton Var
v
  getBV (PatBind {pat_lhs :: forall idL idR. HsBindLR idL idR -> LPat idL
pat_lhs = LPat GhcTc
pat}) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
pat
  getBV (VarBind {var_id :: forall idL idR. HsBindLR idL idR -> IdP idL
var_id = IdP GhcTc
v}) = Var -> Set Var
forall a. a -> Set a
Set.singleton IdP GhcTc
Var
v
  getBV PatSynBind{} = Set Var
forall a. Set a
Set.empty
#if __GLASGOW_HASKELL__ < 904
  getBV (AbsBinds {abs_exports = es}) = Set.fromList (map abe_poly es)
#else
  getBV (XHsBindsLR (AbsBinds {abs_exports :: AbsBinds -> [ABExport]
abs_exports = [ABExport]
es})) = [Var] -> Set Var
forall a. Ord a => [a] -> Set a
Set.fromList ((ABExport -> Var) -> [ABExport] -> [Var]
forall a b. (a -> b) -> [a] -> [b]
map ABExport -> Var
abe_poly [ABExport]
es)
#endif
  
instance HasBV a => HasBV (GenLocated b a) where
  getBV :: GenLocated b a -> Set Var
getBV (L b
_ a
e) = a -> Set Var
forall a. HasBV a => a -> Set Var
getBV a
e

instance HasBV a => HasBV [a] where
  getBV :: [a] -> Set Var
getBV [a]
ps = (Set Var -> a -> Set Var) -> Set Var -> [a] -> Set Var
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Set Var
s a
p -> a -> Set Var
forall a. HasBV a => a -> Set Var
getBV a
p Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set Var
s) Set Var
forall a. Set a
Set.empty [a]
ps

#if __GLASGOW_HASKELL__ >= 904
getRecFieldRhs :: HsFieldBind lhs rhs -> rhs
getRecFieldRhs = HsFieldBind lhs rhs -> rhs
forall lhs rhs. HsFieldBind lhs rhs -> rhs
hfbRHS
#else
getRecFieldRhs = hsRecFieldArg
#endif

getConBV :: HsConDetails tyarg a (HsRecFields p arg) -> Set Var
getConBV (PrefixCon [tyarg]
_ [a]
ps) = [a] -> Set Var
forall a. HasBV a => a -> Set Var
getBV [a]
ps
getConBV (InfixCon a
p a
p') = a -> Set Var
forall a. HasBV a => a -> Set Var
getBV a
p Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` a -> Set Var
forall a. HasBV a => a -> Set Var
getBV a
p'
getConBV (RecCon (HsRecFields {rec_flds :: forall p arg. HsRecFields p arg -> [LHsRecField p arg]
rec_flds = [XRec p (HsFieldBind (XRec p (FieldOcc p)) arg)]
fs})) = (Set Var
 -> GenLocated l (HsFieldBind (XRec p (FieldOcc p)) arg) -> Set Var)
-> Set Var
-> [GenLocated l (HsFieldBind (XRec p (FieldOcc p)) arg)]
-> Set Var
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Set Var
-> GenLocated l (HsFieldBind (XRec p (FieldOcc p)) arg) -> Set Var
forall {a} {l} {lhs}.
HasBV a =>
Set Var -> GenLocated l (HsFieldBind lhs a) -> Set Var
run Set Var
forall a. Set a
Set.empty [XRec p (HsFieldBind (XRec p (FieldOcc p)) arg)]
[GenLocated l (HsFieldBind (XRec p (FieldOcc p)) arg)]
fs
      where run :: Set Var -> GenLocated l (HsFieldBind lhs a) -> Set Var
run Set Var
s (L l
_ HsFieldBind lhs a
f) = a -> Set Var
forall a. HasBV a => a -> Set Var
getBV (HsFieldBind lhs a -> a
forall lhs rhs. HsFieldBind lhs rhs -> rhs
getRecFieldRhs HsFieldBind lhs a
f) Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set Var
s

#if __GLASGOW_HASKELL__ < 904
instance HasBV CoPat where
  getBV CoPat {co_pat_inner = p} = getBV p
#else
instance HasBV XXPatGhcTc where
  getBV :: XXPatGhcTc -> Set Var
getBV CoPat {co_pat_inner :: XXPatGhcTc -> Pat GhcTc
co_pat_inner = Pat GhcTc
p} = Pat GhcTc -> Set Var
forall a. HasBV a => a -> Set Var
getBV Pat GhcTc
p
  getBV (ExpansionPat Pat GhcRn
_ Pat GhcTc
p) = Pat GhcTc -> Set Var
forall a. HasBV a => a -> Set Var
getBV Pat GhcTc
p
#endif

instance HasBV (Pat GhcTc) where
  getBV :: Pat GhcTc -> Set Var
getBV (VarPat XVarPat GhcTc
_ (L SrcSpanAnnN
_ Var
v)) = Var -> Set Var
forall a. a -> Set a
Set.singleton Var
v
  getBV (LazyPat XLazyPat GhcTc
_ LPat GhcTc
p) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p
#if __GLASGOW_HASKELL__ >= 906
  getBV (AsPat XAsPat GhcTc
_ (L SrcSpanAnnN
_ Var
v) LHsToken "@" GhcTc
_ LPat GhcTc
p) = Var -> Set Var -> Set Var
forall a. Ord a => a -> Set a -> Set a
Set.insert Var
v (GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p)
#else
  getBV (AsPat _ (L _ v) p) = Set.insert v (getBV p)
#endif
  getBV (BangPat XBangPat GhcTc
_ LPat GhcTc
p) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p
  getBV (ListPat XListPat GhcTc
_ [LPat GhcTc]
ps) = [GenLocated SrcSpanAnnA (Pat GhcTc)] -> Set Var
forall a. HasBV a => a -> Set Var
getBV [LPat GhcTc]
[GenLocated SrcSpanAnnA (Pat GhcTc)]
ps
  getBV (TuplePat XTuplePat GhcTc
_ [LPat GhcTc]
ps Boxity
_) = [GenLocated SrcSpanAnnA (Pat GhcTc)] -> Set Var
forall a. HasBV a => a -> Set Var
getBV [LPat GhcTc]
[GenLocated SrcSpanAnnA (Pat GhcTc)]
ps
  getBV (SumPat XSumPat GhcTc
_ LPat GhcTc
p ConTag
_ ConTag
_) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p
  getBV (ViewPat XViewPat GhcTc
_ LHsExpr GhcTc
_ LPat GhcTc
p) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p

  getBV (SplicePat XSplicePat GhcTc
_ HsUntypedSplice GhcTc
sp) =
    case HsUntypedSplice GhcTc
sp of
#if __GLASGOW_HASKELL__ < 906
      HsTypedSplice _ _ v _ -> Set.singleton v
      HsSpliced _ _ (HsSplicedPat p) -> getBV p
      HsUntypedSplice _ _ v _ ->  Set.singleton v
      HsQuasiQuote _ p p' _ _ -> Set.fromList [p,p']
      _ -> Set.empty
#else
      HsUntypedSpliceExpr XUntypedSpliceExpr GhcTc
_ LHsExpr GhcTc
e -> GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
      HsQuasiQuote XQuasiQuote GhcTc
_ IdP GhcTc
v XRec GhcTc FastString
_  -> Var -> Set Var
forall a. a -> Set a
Set.singleton IdP GhcTc
Var
v
#endif

  getBV (NPlusKPat XNPlusKPat GhcTc
_ (L SrcSpanAnnN
_ Var
v) XRec GhcTc (HsOverLit GhcTc)
_ HsOverLit GhcTc
_ SyntaxExpr GhcTc
_ SyntaxExpr GhcTc
_) = Var -> Set Var
forall a. a -> Set a
Set.singleton Var
v
  getBV (NPat {}) = Set Var
forall a. Set a
Set.empty
  getBV (XPat XXPat GhcTc
p) = XXPatGhcTc -> Set Var
forall a. HasBV a => a -> Set Var
getBV XXPat GhcTc
XXPatGhcTc
p
  getBV (WildPat {}) = Set Var
forall a. Set a
Set.empty
  getBV (LitPat {}) = Set Var
forall a. Set a
Set.empty
#if __GLASGOW_HASKELL__ >= 904  
  getBV (ParPat XParPat GhcTc
_ LHsToken "(" GhcTc
_ LPat GhcTc
p LHsToken ")" GhcTc
_) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p
#else
  getBV (ParPat _ p) = getBV p
#endif
  getBV (ConPat {pat_args :: forall p. Pat p -> HsConPatDetails p
pat_args = HsConPatDetails GhcTc
con}) = HsConDetails
  (HsConPatTyArg GhcRn)
  (GenLocated SrcSpanAnnA (Pat GhcTc))
  (HsRecFields GhcTc (GenLocated SrcSpanAnnA (Pat GhcTc)))
-> Set Var
forall {p} {arg} {l} {a} {tyarg}.
(XRec p (HsFieldBind (XRec p (FieldOcc p)) arg)
 ~ GenLocated l (HsFieldBind (XRec p (FieldOcc p)) arg),
 HasBV a, HasBV arg) =>
HsConDetails tyarg a (HsRecFields p arg) -> Set Var
getConBV HsConPatDetails GhcTc
HsConDetails
  (HsConPatTyArg GhcRn)
  (GenLocated SrcSpanAnnA (Pat GhcTc))
  (HsRecFields GhcTc (GenLocated SrcSpanAnnA (Pat GhcTc)))
con
  getBV (SigPat XSigPat GhcTc
_ LPat GhcTc
p HsPatSigType (NoGhcTc GhcTc)
_) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Set Var
forall a. HasBV a => a -> Set Var
getBV LPat GhcTc
GenLocated SrcSpanAnnA (Pat GhcTc)
p

#if __GLASGOW_HASKELL__ < 904
instance HasBV NoExtCon where
  getBV _ = Set.empty
#endif

-- | Syntax that may contain variables.
class HasFV a where
  -- | Compute the set of variables occurring in the given piece of
  -- syntax.  The name falsely suggests that returns free variables,
  -- but in fact it returns all variable occurrences, no matter
  -- whether they are free or bound.
  getFV :: a -> Set Var 

instance HasFV a => HasFV (GenLocated b a) where
  getFV :: GenLocated b a -> Set Var
getFV (L b
_ a
e) = a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
e
  
instance HasFV a => HasFV [a] where
  getFV :: [a] -> Set Var
getFV [a]
es = (a -> Set Var) -> [a] -> Set Var
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> Set Var
forall a. HasFV a => a -> Set Var
getFV [a]
es

instance HasFV a => HasFV (Bag a) where
  getFV :: Bag a -> Set Var
getFV Bag a
es = (a -> Set Var) -> Bag a -> Set Var
forall m a. Monoid m => (a -> m) -> Bag a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> Set Var
forall a. HasFV a => a -> Set Var
getFV Bag a
es

instance HasFV Var where
  getFV :: Var -> Set Var
getFV Var
v = Var -> Set Var
forall a. a -> Set a
Set.singleton Var
v

instance HasFV a => HasFV (MatchGroup GhcTc a) where
  getFV :: MatchGroup GhcTc a -> Set Var
getFV MG {mg_alts :: forall p body. MatchGroup p body -> XRec p [LMatch p body]
mg_alts = XRec GhcTc [LMatch GhcTc a]
alts} = GenLocated
  (Anno [GenLocated (Anno (Match GhcTc a)) (Match GhcTc a)])
  [GenLocated (Anno (Match GhcTc a)) (Match GhcTc a)]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV XRec GhcTc [LMatch GhcTc a]
GenLocated
  (Anno [GenLocated (Anno (Match GhcTc a)) (Match GhcTc a)])
  [GenLocated (Anno (Match GhcTc a)) (Match GhcTc a)]
alts
  
instance HasFV a => HasFV (Match GhcTc a) where
  getFV :: Match GhcTc a -> Set Var
getFV Match {m_grhss :: forall p body. Match p body -> GRHSs p body
m_grhss = GRHSs GhcTc a
rhss} = GRHSs GhcTc a -> Set Var
forall a. HasFV a => a -> Set Var
getFV GRHSs GhcTc a
rhss

instance HasFV (HsTupArg GhcTc) where
  getFV :: HsTupArg GhcTc -> Set Var
getFV (Present XPresent GhcTc
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV Missing {} = Set Var
forall a. Set a
Set.empty

instance HasFV a => HasFV (GRHS GhcTc a) where
  getFV :: GRHS GhcTc a -> Set Var
getFV (GRHS XCGRHS GhcTc a
_ [GuardLStmt GhcTc]
g a
b) = [GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV [GuardLStmt GhcTc]
[GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
g Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
b

instance HasFV a => HasFV (GRHSs GhcTc a) where
  getFV :: GRHSs GhcTc a -> Set Var
getFV GRHSs {grhssGRHSs :: forall p body. GRHSs p body -> [LGRHS p body]
grhssGRHSs = [LGRHS GhcTc a]
rhs, grhssLocalBinds :: forall p body. GRHSs p body -> HsLocalBinds p
grhssLocalBinds = HsLocalBinds GhcTc
lbs} =
    [GenLocated (Anno (GRHS GhcTc a)) (GRHS GhcTc a)] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [LGRHS GhcTc a]
[GenLocated (Anno (GRHS GhcTc a)) (GRHS GhcTc a)]
rhs Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` HsLocalBinds GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsLocalBinds GhcTc
lbs


instance HasFV (HsLocalBindsLR GhcTc GhcTc) where
  getFV :: HsLocalBinds GhcTc -> Set Var
getFV (HsValBinds XHsValBinds GhcTc GhcTc
_ HsValBindsLR GhcTc GhcTc
bs) = HsValBindsLR GhcTc GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsValBindsLR GhcTc GhcTc
bs
  getFV (HsIPBinds XHsIPBinds GhcTc GhcTc
_ HsIPBinds GhcTc
bs) = HsIPBinds GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsIPBinds GhcTc
bs
  getFV EmptyLocalBinds {} = Set Var
forall a. Set a
Set.empty
  
instance HasFV (HsValBindsLR GhcTc GhcTc) where
  getFV :: HsValBindsLR GhcTc GhcTc -> Set Var
getFV (ValBinds XValBinds GhcTc GhcTc
_ Bag (LHsBindLR GhcTc GhcTc)
b [LSig GhcTc]
_) = Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV Bag (LHsBindLR GhcTc GhcTc)
Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc))
b
  getFV (XValBindsLR XXValBindsLR GhcTc GhcTc
b) = NHsValBindsLR GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV XXValBindsLR GhcTc GhcTc
NHsValBindsLR GhcTc
b

instance HasFV (NHsValBindsLR GhcTc) where
  getFV :: NHsValBindsLR GhcTc -> Set Var
getFV (NValBinds [(RecFlag, Bag (LHsBindLR GhcTc GhcTc))]
bs [LSig GhcRn]
_) = ((RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))
 -> Set Var)
-> [(RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))]
-> Set Var
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV (Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)) -> Set Var)
-> ((RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))
    -> Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))
-> (RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))
-> Set Var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))
-> Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc))
forall a b. (a, b) -> b
snd) [(RecFlag, Bag (LHsBindLR GhcTc GhcTc))]
[(RecFlag, Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)))]
bs

instance HasFV (HsBindLR GhcTc GhcTc) where
  getFV :: HsBindLR GhcTc GhcTc -> Set Var
getFV FunBind {fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcTc (LHsExpr GhcTc)
ms} = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsExpr GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
ms
  getFV PatBind {pat_rhs :: forall idL idR. HsBindLR idL idR -> GRHSs idR (LHsExpr idR)
pat_rhs = GRHSs GhcTc (LHsExpr GhcTc)
rhs} = GRHSs GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV GRHSs GhcTc (LHsExpr GhcTc)
GRHSs GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
rhs
  getFV VarBind {var_rhs :: forall idL idR. HsBindLR idL idR -> LHsExpr idR
var_rhs = LHsExpr GhcTc
rhs} = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
rhs
  getFV PatSynBind {} = Set Var
forall a. Set a
Set.empty
#if __GLASGOW_HASKELL__ < 904
  getFV AbsBinds {abs_binds = bs} = getFV bs
#else
  getFV (XHsBindsLR AbsBinds {abs_binds :: AbsBinds -> Bag (LHsBindLR GhcTc GhcTc)
abs_binds = Bag (LHsBindLR GhcTc GhcTc)
bs}) = Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV Bag (LHsBindLR GhcTc GhcTc)
Bag (GenLocated SrcSpanAnnA (HsBindLR GhcTc GhcTc))
bs
#endif

instance HasFV (IPBind GhcTc) where
  getFV :: IPBind GhcTc -> Set Var
getFV (IPBind XCIPBind GhcTc
_ XRec GhcTc HsIPName
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e

instance HasFV (HsIPBinds GhcTc) where
  getFV :: HsIPBinds GhcTc -> Set Var
getFV (IPBinds XIPBinds GhcTc
_ [LIPBind GhcTc]
bs) = [GenLocated SrcSpanAnnA (IPBind GhcTc)] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [LIPBind GhcTc]
[GenLocated SrcSpanAnnA (IPBind GhcTc)]
bs
  
instance HasFV (ApplicativeArg GhcTc) where
  getFV :: ApplicativeArg GhcTc -> Set Var
getFV ApplicativeArgOne { arg_expr :: forall idL. ApplicativeArg idL -> LHsExpr idL
arg_expr = LHsExpr GhcTc
e }     = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV ApplicativeArgMany {app_stmts :: forall idL. ApplicativeArg idL -> [ExprLStmt idL]
app_stmts = [GuardLStmt GhcTc]
es, final_expr :: forall idL. ApplicativeArg idL -> HsExpr idL
final_expr = HsExpr GhcTc
e} = [GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV [GuardLStmt GhcTc]
[GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
es Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` HsExpr GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsExpr GhcTc
e

instance HasFV (ParStmtBlock GhcTc GhcTc) where
  getFV :: ParStmtBlock GhcTc GhcTc -> Set Var
getFV (ParStmtBlock XParStmtBlock GhcTc GhcTc
_ [GuardLStmt GhcTc]
es [IdP GhcTc]
_ SyntaxExpr GhcTc
_) = [GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV [GuardLStmt GhcTc]
[GenLocated
   SrcSpanAnnA
   (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
es
  
instance HasFV a => HasFV (StmtLR GhcTc GhcTc a) where
  getFV :: StmtLR GhcTc GhcTc a -> Set Var
getFV (LastStmt XLastStmt GhcTc GhcTc a
_ a
e Maybe Bool
_ SyntaxExpr GhcTc
_) = a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
e
  getFV (BindStmt XBindStmt GhcTc GhcTc a
_ LPat GhcTc
_ a
e) = a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
e
  getFV (ApplicativeStmt XApplicativeStmt GhcTc GhcTc a
_ [(SyntaxExpr GhcTc, ApplicativeArg GhcTc)]
args Maybe (SyntaxExpr GhcTc)
_) = ((SyntaxExprTc, ApplicativeArg GhcTc) -> Set Var)
-> [(SyntaxExprTc, ApplicativeArg GhcTc)] -> Set Var
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (ApplicativeArg GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV (ApplicativeArg GhcTc -> Set Var)
-> ((SyntaxExprTc, ApplicativeArg GhcTc) -> ApplicativeArg GhcTc)
-> (SyntaxExprTc, ApplicativeArg GhcTc)
-> Set Var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SyntaxExprTc, ApplicativeArg GhcTc) -> ApplicativeArg GhcTc
forall a b. (a, b) -> b
snd) [(SyntaxExpr GhcTc, ApplicativeArg GhcTc)]
[(SyntaxExprTc, ApplicativeArg GhcTc)]
args
  getFV (BodyStmt XBodyStmt GhcTc GhcTc a
_ a
e SyntaxExpr GhcTc
_ SyntaxExpr GhcTc
_) = a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
e
  getFV (LetStmt XLetStmt GhcTc GhcTc a
_ HsLocalBinds GhcTc
bs) = HsLocalBinds GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsLocalBinds GhcTc
bs
  getFV (ParStmt XParStmt GhcTc GhcTc a
_ [ParStmtBlock GhcTc GhcTc]
stms HsExpr GhcTc
e SyntaxExpr GhcTc
_) = [ParStmtBlock GhcTc GhcTc] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [ParStmtBlock GhcTc GhcTc]
stms Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` HsExpr GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsExpr GhcTc
e
  getFV TransStmt{} = Set Var
forall a. Set a
Set.empty -- TODO
  getFV RecStmt{} = Set Var
forall a. Set a
Set.empty -- TODO


instance HasFV (HsRecFields GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))) where
  getFV :: HsRecFields GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> Set Var
getFV HsRecFields{rec_flds :: forall p arg. HsRecFields p arg -> [LHsRecField p arg]
rec_flds = [LHsRecField GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))]
fs} = [GenLocated
   SrcSpanAnnA
   (HsFieldBind
      (GenLocated (SrcAnn NoEpAnns) (FieldOcc GhcTc))
      (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV [LHsRecField GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))]
[GenLocated
   SrcSpanAnnA
   (HsFieldBind
      (GenLocated (SrcAnn NoEpAnns) (FieldOcc GhcTc))
      (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
fs

#if __GLASGOW_HASKELL__ >= 904
instance HasFV (HsFieldBind o (GenLocated SrcSpanAnnA (HsExpr GhcTc))) where
#else
instance HasFV (HsRecField' o (GenLocated SrcSpanAnnA (HsExpr GhcTc))) where
#endif
  getFV :: HsFieldBind o (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
getFV HsFieldBind o (GenLocated SrcSpanAnnA (HsExpr GhcTc))
rf  = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV (HsFieldBind o (GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> GenLocated SrcSpanAnnA (HsExpr GhcTc)
forall lhs rhs. HsFieldBind lhs rhs -> rhs
getRecFieldRhs HsFieldBind o (GenLocated SrcSpanAnnA (HsExpr GhcTc))
rf)

instance HasFV (ArithSeqInfo GhcTc) where
  getFV :: ArithSeqInfo GhcTc -> Set Var
getFV (From LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (FromThen LHsExpr GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (FromTo LHsExpr GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (FromThenTo LHsExpr GhcTc
e1 LHsExpr GhcTc
e2 LHsExpr GhcTc
e3) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e3
  
#if __GLASGOW_HASKELL__ >= 904
instance HasFV (HsQuote GhcTc) where
#else
instance HasFV (HsBracket GhcTc) where
#endif
  getFV :: HsQuote GhcTc -> Set Var
getFV (ExpBr XExpBr GhcTc
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (VarBr XVarBr GhcTc
_ Bool
_ LIdP GhcTc
e) = GenLocated SrcSpanAnnN Var -> Set Var
forall a. HasFV a => a -> Set Var
getFV LIdP GhcTc
GenLocated SrcSpanAnnN Var
e
  getFV HsQuote GhcTc
_ = Set Var
forall a. Set a
Set.empty

instance HasFV (HsCmd GhcTc) where
  getFV :: HsCmd GhcTc -> Set Var
getFV (HsCmdArrApp XCmdArrApp GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2 HsArrAppType
_ Bool
_) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (HsCmdArrForm XCmdArrForm GhcTc
_ LHsExpr GhcTc
e LexicalFixity
_ Maybe Fixity
_ [LHsCmdTop GhcTc]
cmd) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` [GenLocated (SrcAnn NoEpAnns) (HsCmdTop GhcTc)] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [LHsCmdTop GhcTc]
[GenLocated (SrcAnn NoEpAnns) (HsCmdTop GhcTc)]
cmd
  getFV (HsCmdApp XCmdApp GhcTc
_ LHsCmd GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsCmd GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmd GhcTc
GenLocated SrcSpanAnnA (HsCmd GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (HsCmdLam XCmdLam GhcTc
_ MatchGroup GhcTc (LHsCmd GhcTc)
l) = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsCmd GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc))
l
  getFV (HsCmdCase XCmdCase GhcTc
_ LHsExpr GhcTc
_ MatchGroup GhcTc (LHsCmd GhcTc)
mg) = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsCmd GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc))
mg
  getFV (HsCmdIf XCmdIf GhcTc
_ SyntaxExpr GhcTc
_ LHsExpr GhcTc
e1 LHsCmd GhcTc
e2 LHsCmd GhcTc
e3) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsCmd GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmd GhcTc
GenLocated SrcSpanAnnA (HsCmd GhcTc)
e2 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsCmd GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmd GhcTc
GenLocated SrcSpanAnnA (HsCmd GhcTc)
e3
  getFV (HsCmdDo XCmdDo GhcTc
_ XRec GhcTc [CmdLStmt GhcTc]
cmd) = GenLocated
  SrcSpanAnnL
  [GenLocated
     SrcSpanAnnA
     (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV XRec GhcTc [CmdLStmt GhcTc]
GenLocated
  SrcSpanAnnL
  [GenLocated
     SrcSpanAnnA
     (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc)))]
cmd
#if __GLASGOW_HASKELL__ >= 904
  getFV (HsCmdPar XCmdPar GhcTc
_ LHsToken "(" GhcTc
_ LHsCmd GhcTc
cmd LHsToken ")" GhcTc
_) = GenLocated SrcSpanAnnA (HsCmd GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmd GhcTc
GenLocated SrcSpanAnnA (HsCmd GhcTc)
cmd
  getFV (HsCmdLet XCmdLet GhcTc
_ LHsToken "let" GhcTc
_ HsLocalBinds GhcTc
bs LHsToken "in" GhcTc
_ LHsCmd GhcTc
_) = HsLocalBinds GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsLocalBinds GhcTc
bs
#else
  getFV (HsCmdPar _ cmd) = getFV cmd
  getFV (HsCmdLet _ bs _) = getFV bs
#endif
#if __GLASGOW_HASKELL__ >= 904
  getFV (HsCmdLamCase XCmdLamCase GhcTc
_ LamCaseVariant
_ MatchGroup GhcTc (LHsCmd GhcTc)
mg) = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsCmd GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsCmd GhcTc))
mg
#else
  getFV (HsCmdLamCase _ mg) = getFV mg
#endif
  getFV (XCmd XXCmd GhcTc
e) = HsWrap HsCmd -> Set Var
forall a. HasFV a => a -> Set Var
getFV XXCmd GhcTc
HsWrap HsCmd
e


instance (HasFV a, HasFV b) => HasFV (Either a b) where
  getFV :: Either a b -> Set Var
getFV (Left a
x) = a -> Set Var
forall a. HasFV a => a -> Set Var
getFV a
x
  getFV (Right b
x) = b -> Set Var
forall a. HasFV a => a -> Set Var
getFV b
x

#if __GLASGOW_HASKELL__ >= 908
instance HasFV (LHsRecUpdFields GhcTc) where
  getFV RegularRecUpdFields {recUpdFields = x} = getFV x
  getFV OverloadedRecUpdFields {olRecUpdFields = x} = getFV x
#endif

instance HasFV (HsCmdTop GhcTc) where
  getFV :: HsCmdTop GhcTc -> Set Var
getFV (HsCmdTop XCmdTop GhcTc
_ LHsCmd GhcTc
cmd) = GenLocated SrcSpanAnnA (HsCmd GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmd GhcTc
GenLocated SrcSpanAnnA (HsCmd GhcTc)
cmd

instance HasFV (HsExpr GhcTc) where
  getFV :: HsExpr GhcTc -> Set Var
getFV (HsVar XVar GhcTc
_ LIdP GhcTc
v) = GenLocated SrcSpanAnnN Var -> Set Var
forall a. HasFV a => a -> Set Var
getFV LIdP GhcTc
GenLocated SrcSpanAnnN Var
v
  getFV HsUnboundVar {} = Set Var
forall a. Set a
Set.empty
  getFV HsOverLabel {} = Set Var
forall a. Set a
Set.empty
  getFV HsIPVar {} = Set Var
forall a. Set a
Set.empty
  getFV HsOverLit {} = Set Var
forall a. Set a
Set.empty
  getFV HsLit {} = Set Var
forall a. Set a
Set.empty
  getFV (HsLam XLam GhcTc
_ MatchGroup GhcTc (LHsExpr GhcTc)
mg) = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsExpr GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
mg
  getFV (HsApp XApp GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2      
  getFV (OpApp XOpApp GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2 LHsExpr GhcTc
e3) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e3
  getFV (NegApp XNegApp GhcTc
_ LHsExpr GhcTc
e SyntaxExpr GhcTc
_) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (SectionL XSectionL GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (SectionR XSectionR GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2
  getFV (ExplicitTuple XExplicitTuple GhcTc
_ [HsTupArg GhcTc]
es Boxity
_) = [HsTupArg GhcTc] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [HsTupArg GhcTc]
es
  getFV (ExplicitSum XExplicitSum GhcTc
_ ConTag
_ ConTag
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (HsCase XCase GhcTc
_ LHsExpr GhcTc
e MatchGroup GhcTc (LHsExpr GhcTc)
mg) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e  Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsExpr GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
mg
  getFV (HsMultiIf XMultiIf GhcTc
_ [LGRHS GhcTc (LHsExpr GhcTc)]
es) = [GenLocated
   (SrcAnn NoEpAnns)
   (GRHS GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV [LGRHS GhcTc (LHsExpr GhcTc)]
[GenLocated
   (SrcAnn NoEpAnns)
   (GRHS GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
es
  getFV (HsDo XDo GhcTc
_ HsDoFlavour
_ XRec GhcTc [GuardLStmt GhcTc]
e) = GenLocated
  SrcSpanAnnL
  [GenLocated
     SrcSpanAnnA
     (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV XRec GhcTc [GuardLStmt GhcTc]
GenLocated
  SrcSpanAnnL
  [GenLocated
     SrcSpanAnnA
     (StmtLR GhcTc GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
e
  getFV HsProjection {} = Set Var
forall a. Set a
Set.empty
  getFV HsGetField {gf_expr :: forall p. HsExpr p -> LHsExpr p
gf_expr = LHsExpr GhcTc
e} = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (ExplicitList XExplicitList GhcTc
_ [LHsExpr GhcTc]
es) = [GenLocated SrcSpanAnnA (HsExpr GhcTc)] -> Set Var
forall a. HasFV a => a -> Set Var
getFV [LHsExpr GhcTc]
[GenLocated SrcSpanAnnA (HsExpr GhcTc)]
es
  getFV (RecordUpd {rupd_expr :: forall p. HsExpr p -> LHsExpr p
rupd_expr = LHsExpr GhcTc
e, rupd_flds :: forall p. HsExpr p -> Either [LHsRecUpdField p] [LHsRecUpdProj p]
rupd_flds = Either [LHsRecUpdField GhcTc] [LHsRecUpdProj GhcTc]
fs}) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Either
  [GenLocated
     SrcSpanAnnA
     (HsFieldBind
        (GenLocated (SrcAnn NoEpAnns) (AmbiguousFieldOcc GhcTc))
        (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
  [GenLocated
     SrcSpanAnnA
     (HsFieldBind
        (GenLocated (SrcAnn NoEpAnns) (FieldLabelStrings GhcTc))
        (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
-> Set Var
forall a. HasFV a => a -> Set Var
getFV Either [LHsRecUpdField GhcTc] [LHsRecUpdProj GhcTc]
Either
  [GenLocated
     SrcSpanAnnA
     (HsFieldBind
        (GenLocated (SrcAnn NoEpAnns) (AmbiguousFieldOcc GhcTc))
        (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
  [GenLocated
     SrcSpanAnnA
     (HsFieldBind
        (GenLocated (SrcAnn NoEpAnns) (FieldLabelStrings GhcTc))
        (GenLocated SrcSpanAnnA (HsExpr GhcTc)))]
fs
  getFV (RecordCon {rcon_flds :: forall p. HsExpr p -> HsRecordBinds p
rcon_flds = HsRecordBinds GhcTc
fs}) = HsRecFields GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> Set Var
forall a. HasFV a => a -> Set Var
getFV HsRecordBinds GhcTc
HsRecFields GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
fs
  getFV (ArithSeq XArithSeq GhcTc
_ Maybe (SyntaxExpr GhcTc)
_ ArithSeqInfo GhcTc
e) = ArithSeqInfo GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV ArithSeqInfo GhcTc
e
#if __GLASGOW_HASKELL__ >= 906
  getFV HsTypedSplice{} = Set Var
forall a. Set a
Set.empty
  getFV HsUntypedSplice{} = Set Var
forall a. Set a
Set.empty
#else
  getFV HsSpliceE{} = Set.empty
#endif
  getFV (HsProc XProc GhcTc
_ LPat GhcTc
_ LHsCmdTop GhcTc
e) = GenLocated (SrcAnn NoEpAnns) (HsCmdTop GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsCmdTop GhcTc
GenLocated (SrcAnn NoEpAnns) (HsCmdTop GhcTc)
e
  getFV (HsStatic XStatic GhcTc
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (XExpr XXExpr GhcTc
e) = XXExprGhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV XXExpr GhcTc
XXExprGhcTc
e
#if __GLASGOW_HASKELL__ >= 904
  getFV (HsPar XPar GhcTc
_ LHsToken "(" GhcTc
_ LHsExpr GhcTc
e LHsToken ")" GhcTc
_) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e  
  getFV (HsLamCase XLamCase GhcTc
_ LamCaseVariant
_ MatchGroup GhcTc (LHsExpr GhcTc)
mg) = MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc)) -> Set Var
forall a. HasFV a => a -> Set Var
getFV MatchGroup GhcTc (LHsExpr GhcTc)
MatchGroup GhcTc (GenLocated SrcSpanAnnA (HsExpr GhcTc))
mg
  getFV (HsLet XLet GhcTc
_ LHsToken "let" GhcTc
_ HsLocalBinds GhcTc
bs LHsToken "in" GhcTc
_ LHsExpr GhcTc
e) = HsLocalBinds GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsLocalBinds GhcTc
bs Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV HsRecSel {} = Set Var
forall a. Set a
Set.empty
  getFV (HsTypedBracket XTypedBracket GhcTc
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (HsUntypedBracket XUntypedBracket GhcTc
_ HsQuote GhcTc
e) = HsQuote GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsQuote GhcTc
e
#else  
  getFV (HsBinTick _ _ _ e) = getFV e
  getFV (HsTick _ _ e) = getFV e
  getFV (HsLet _ bs e) = getFV bs `Set.union` getFV e
  getFV (HsPar _ e) = getFV e
  getFV (HsLamCase _ mg) = getFV mg
  getFV HsConLikeOut {} = Set.empty
  getFV HsRecFld {} = Set.empty
  getFV (HsBracket _ e) = getFV e
  getFV HsRnBracketOut {} = Set.empty
  getFV HsTcBracketOut {} = Set.empty
#endif

#if __GLASGOW_HASKELL__ >= 906
  getFV (HsAppType XAppTypeE GhcTc
_ LHsExpr GhcTc
e LHsToken "@" GhcTc
_ LHsWcType (NoGhcTc GhcTc)
_) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (ExprWithTySig XExprWithTySig GhcTc
_ LHsExpr GhcTc
e LHsSigWcType (NoGhcTc GhcTc)
_) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e  
#else
  getFV (HsAppType _ e _) = getFV e
  getFV (ExprWithTySig _ e _) = getFV e  
#endif
  getFV (HsIf XIf GhcTc
_ LHsExpr GhcTc
e1 LHsExpr GhcTc
e2 LHsExpr GhcTc
e3) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e1 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e2 Set Var -> Set Var -> Set Var
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e3
  getFV (HsPragE XPragE GhcTc
_ HsPragE GhcTc
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e


instance HasFV XXExprGhcTc where
  getFV :: XXExprGhcTc -> Set Var
getFV (WrapExpr HsWrap HsExpr
e) = HsWrap HsExpr -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsWrap HsExpr
e
  getFV (ExpansionExpr (HsExpanded HsExpr GhcRn
_e1 HsExpr GhcTc
e2)) = HsExpr GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV HsExpr GhcTc
e2
#if __GLASGOW_HASKELL__ >= 904  
  getFV (HsTick CoreTickish
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV (HsBinTick ConTag
_ ConTag
_ LHsExpr GhcTc
e) = GenLocated SrcSpanAnnA (HsExpr GhcTc) -> Set Var
forall a. HasFV a => a -> Set Var
getFV LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
e
  getFV ConLikeTc{} = Set Var
forall a. Set a
Set.empty
#endif


instance HasFV (e GhcTc) => HasFV (HsWrap e) where
  getFV :: HsWrap e -> Set Var
getFV (HsWrap HsWrapper
_ e GhcTc
e) = e GhcTc -> Set Var
forall a. HasFV a => a -> Set Var
getFV e GhcTc
e