{-# OPTIONS_GHC -fno-warn-duplicate-exports -fno-warn-orphans #-}
module GHC.Plugins
( module GHC.Driver.Plugins
, module GHC.Types.Name.Reader
, module GHC.Types.Name.Occurrence
, module GHC.Types.Name
, module GHC.Types.Var
, module GHC.Types.Id
, module GHC.Types.Id.Info
, module GHC.Types.PkgQual
, module GHC.Core.Opt.Monad
, module GHC.Core.Opt.Pipeline.Types
, module GHC.Core.Opt.Stats
, module GHC.Core
, module GHC.Types.Literal
, module GHC.Core.DataCon
, module GHC.Core.Utils
, module GHC.Core.Make
, module GHC.Core.FVs
, module GHC.Core.Subst
, module GHC.Core.Rules
, module GHC.Types.Annotations
, module GHC.Driver.Session
, module GHC.Driver.Ppr
, module GHC.Unit.State
, module GHC.Unit.Module
, module GHC.Unit.Home
, module GHC.Core.Type
, module GHC.Core.TyCon
, module GHC.Core.Coercion
, module GHC.Builtin.Types
, module GHC.Driver.Env
, module GHC.Types.Basic
, module GHC.Types.Var.Set
, module GHC.Types.Var.Env
, module GHC.Types.Name.Set
, module GHC.Types.Name.Env
, module GHC.Types.Unique
, module GHC.Types.Unique.Set
, module GHC.Types.Unique.FM
, module GHC.Data.FiniteMap
, module GHC.Utils.Misc
, module GHC.Serialized
, module GHC.Types.SrcLoc
, module GHC.Utils.Outputable
, module GHC.Utils.Panic
, module GHC.Types.Unique.Supply
, module GHC.Data.FastString
, module GHC.Tc.Errors.Hole.FitTypes
, module GHC.Tc.Errors.Hole.Plugin
, module GHC.Unit.Module.ModGuts
, module GHC.Unit.Module.ModSummary
, module GHC.Unit.Module.ModIface
, module GHC.Types.Meta
, module GHC.Types.SourceError
, module GHC.Parser.Errors.Types
, module GHC.Types.Error
, module GHC.Hs
,
thNameToGhcName
, thNameToGhcNameIO
)
where
import GHC.Driver.Plugins
import GHC.Types.TyThing
import GHC.Types.PkgQual
import GHC.Types.SourceError
import GHC.Types.Name.Reader
import GHC.Types.Name.Occurrence hiding ( varName )
import GHC.Types.Name hiding ( varName )
import GHC.Types.Var
import GHC.Types.Id hiding ( lazySetIdInfo, setIdExported, setIdNotExported )
import GHC.Types.Id.Info
import GHC.Core.Opt.Monad
import GHC.Core.Opt.Pipeline.Types
import GHC.Core.Opt.Stats
import GHC.Core
import GHC.Types.Literal
import GHC.Core.DataCon
import GHC.Core.Utils
import GHC.Core.Make
import GHC.Core.FVs
import GHC.Core.Subst hiding( substTyVarBndr, substCoVarBndr, extendCvSubst, extendSubstInScopeSet )
import GHC.Core.Rules
import GHC.Types.Annotations
import GHC.Types.Meta
import GHC.Driver.Session
import GHC.Unit.State
import GHC.Unit.Home
import GHC.Unit.Module
import GHC.Unit.Module.ModGuts
import GHC.Unit.Module.ModSummary
import GHC.Unit.Module.ModIface
import GHC.Core.Type hiding
( substTy, extendTvSubst, extendTvSubstList, isInScope )
import GHC.Core.Coercion hiding
( substCo )
import GHC.Core.TyCon
import GHC.Builtin.Types
import GHC.Driver.Env
import GHC.Types.Basic
import GHC.Types.Var.Set
import GHC.Types.Var.Env
import GHC.Types.Name.Set
import GHC.Types.Name.Env
import GHC.Types.Unique.Set
import GHC.Types.Unique.FM
import GHC.Data.FiniteMap
import GHC.Utils.Misc
import GHC.Serialized
import GHC.Types.SrcLoc
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Driver.Ppr
import GHC.Types.Unique.Supply
import GHC.Types.Unique ( Unique, Uniquable(..) )
import GHC.Data.FastString
import Data.Maybe
import GHC.Iface.Env ( lookupNameCache )
import GHC.Prelude
import GHC.Utils.Monad ( mapMaybeM )
import GHC.ThToHs ( thRdrNameGuesses )
import GHC.Tc.Utils.Env ( lookupGlobal )
import GHC.Types.Name.Cache ( NameCache )
import GHC.Tc.Errors.Hole.FitTypes
import GHC.Tc.Errors.Hole.Plugin
import GHC.Parser.Errors.Types ( PsWarning, PsError )
import GHC.Types.Error ( Messages )
import GHC.Hs ( HsParsedModule )
import qualified GHC.Internal.TH.Syntax as TH
instance MonadThings CoreM where
lookupThing :: Name -> CoreM TyThing
lookupThing Name
name = do { hsc_env <- CoreM HscEnv
getHscEnv
; liftIO $ lookupGlobal hsc_env name }
thNameToGhcName :: TH.Name -> CoreM (Maybe Name)
thNameToGhcName :: Name -> CoreM (Maybe Name)
thNameToGhcName Name
th_name = do
hsc_env <- CoreM HscEnv
getHscEnv
liftIO $ thNameToGhcNameIO (hsc_NC hsc_env) th_name
thNameToGhcNameIO :: NameCache -> TH.Name -> IO (Maybe Name)
thNameToGhcNameIO :: NameCache -> Name -> IO (Maybe Name)
thNameToGhcNameIO NameCache
cache Name
th_name
= do { names <- (RdrName -> IO (Maybe Name)) -> [RdrName] -> IO [Name]
forall (m :: * -> *) a b.
Applicative m =>
(a -> m (Maybe b)) -> [a] -> m [b]
mapMaybeM RdrName -> IO (Maybe Name)
lookup (Name -> [RdrName]
thRdrNameGuesses Name
th_name)
; return (listToMaybe names) }
where
lookup :: RdrName -> IO (Maybe Name)
lookup RdrName
rdr_name
| Just Name
n <- RdrName -> Maybe Name
isExact_maybe RdrName
rdr_name
= Maybe Name -> IO (Maybe Name)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Name -> IO (Maybe Name)) -> Maybe Name -> IO (Maybe Name)
forall a b. (a -> b) -> a -> b
$ if Name -> Bool
isExternalName Name
n then Name -> Maybe Name
forall a. a -> Maybe a
Just Name
n else Maybe Name
forall a. Maybe a
Nothing
| Just (Module
rdr_mod, OccName
rdr_occ) <- RdrName -> Maybe (Module, OccName)
isOrig_maybe RdrName
rdr_name
= Name -> Maybe Name
forall a. a -> Maybe a
Just (Name -> Maybe Name) -> IO Name -> IO (Maybe Name)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NameCache -> Module -> OccName -> IO Name
lookupNameCache NameCache
cache Module
rdr_mod OccName
rdr_occ
| Bool
otherwise = Maybe Name -> IO (Maybe Name)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Name
forall a. Maybe a
Nothing