    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE CPP #-}

    -- | Definitions for writing /plugins/ for GHC. Plugins can hook into
    -- several areas of the compiler. See the 'Plugin' type. These plugins
    -- include type-checker plugins, source plugins, and core-to-core plugins.

    module GHC.Driver.Plugins (
          -- * Plugins
          Plugin(..)
        , defaultPlugin
        , CommandLineOption
          -- ** Recompilation checking
        , purePlugin, impurePlugin, flagRecompile
        , PluginRecompile(..)

          -- * Plugin types
          -- ** Frontend plugins
        , FrontendPlugin(..), defaultFrontendPlugin, FrontendPluginAction
          -- ** Core plugins
          -- | Core plugins allow plugins to register as a Core-to-Core pass.
        , CorePlugin
          -- ** Typechecker plugins
          -- | Typechecker plugins allow plugins to provide evidence to the
          -- typechecker.
        , TcPlugin
          -- ** Source plugins
          -- | GHC offers a number of points where plugins can access and modify its
          -- front-end (\"source\") representation. These include:
          --
          -- - access to the parser result with 'parsedResultAction'
          -- - access to the renamed AST with 'renamedResultAction'
          -- - access to the typechecked AST with 'typeCheckResultAction'
          -- - access to the Template Haskell splices with 'spliceRunAction'
          -- - access to loaded interface files with 'interfaceLoadAction'
          --
        , keepRenamedSource
          -- ** Hole fit plugins
          -- | hole fit plugins allow plugins to change the behavior of valid hole
          -- fit suggestions
        , HoleFitPluginR

          -- * Internal
        , PluginWithArgs(..), plugins, pluginRecompile'
        , LoadedPlugin(..), lpModuleName
        , StaticPlugin(..)
        , mapPlugins, withPlugins, withPlugins_
        ) where

    import GHC.Prelude

    import GHC.Driver.Env
    import GHC.Driver.Monad
    import GHC.Driver.Phases

    import GHC.Unit.Module
    import GHC.Unit.Module.ModIface
    import GHC.Unit.Module.ModSummary

    import qualified GHC.Tc.Types
    import GHC.Tc.Types ( TcGblEnv, IfM, TcM, tcg_rn_decls, tcg_rn_exports  )
    import GHC.Tc.Errors.Hole.FitTypes ( HoleFitPluginR )

    import GHC.Core.Opt.Monad ( CoreToDo, CoreM )
    import GHC.Hs
    import GHC.Utils.Fingerprint
    import GHC.Utils.Outputable (Outputable(..), text, (<+>))

    import Data.List (sort)

    --Qualified import so we can define a Semigroup instance
    -- but it doesn't clash with Outputable.<>
    import qualified Data.Semigroup

    import Control.Monad

    -- | Command line options gathered from the -PModule.Name:stuff syntax
    -- are given to you as this type
    type CommandLineOption = String

    -- | 'Plugin' is the compiler plugin data type. Try to avoid
    -- constructing one of these directly, and just modify some fields of
    -- 'defaultPlugin' instead: this is to try and preserve source-code
    -- compatibility when we add fields to this.
    --
    -- Nonetheless, this API is preliminary and highly likely to change in
    -- the future.
    data Plugin = Plugin {
        Plugin -> CorePlugin
    installCoreToDos :: CorePlugin
        -- ^ Modify the Core pipeline that will be used for compilation.
        -- This is called as the Core pipeline is built for every module
        -- being compiled, and plugins get the opportunity to modify the
        -- pipeline in a nondeterministic order.
      , Plugin -> TcPlugin
    tcPlugin :: TcPlugin
        -- ^ An optional typechecker plugin, which may modify the
        -- behaviour of the constraint solver.
      , Plugin -> HoleFitPlugin
    holeFitPlugin :: HoleFitPlugin
        -- ^ An optional plugin to handle hole fits, which may re-order
        --   or change the list of valid hole fits and refinement hole fits.

      , Plugin -> [CommandLineOption] -> HscEnv -> IO HscEnv
    driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
        -- ^ An optional plugin to update 'HscEnv', right after plugin loading. This
        -- can be used to register hooks or tweak any field of 'DynFlags' before
        -- doing actual work on a module.
        --
        --   @since 8.10.1

      , Plugin -> [CommandLineOption] -> IO PluginRecompile
    pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
        -- ^ Specify how the plugin should affect recompilation.
      , Plugin
    -> [CommandLineOption]
    -> ModSummary
    -> HsParsedModule
    -> Hsc HsParsedModule
    parsedResultAction :: [CommandLineOption] -> ModSummary -> HsParsedModule
                                -> Hsc HsParsedModule
        -- ^ Modify the module when it is parsed. This is called by
        -- "GHC.Driver.Main" when the parsing is successful.
      , Plugin
    -> [CommandLineOption]
    -> TcGblEnv
    -> HsGroup GhcRn
    -> TcM (TcGblEnv, HsGroup GhcRn)
    renamedResultAction :: [CommandLineOption] -> TcGblEnv
                                    -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
        -- ^ Modify each group after it is renamed. This is called after each
        -- `HsGroup` has been renamed.
      , Plugin
    -> [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
    typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv
                                   -> TcM TcGblEnv
        -- ^ Modify the module when it is type checked. This is called at the
        -- very end of typechecking.
      , Plugin
    -> [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
    spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc
                             -> TcM (LHsExpr GhcTc)
        -- ^ Modify the TH splice or quasiqoute before it is run.
      , Plugin
    -> forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
    interfaceLoadAction :: forall lcl . [CommandLineOption] -> ModIface
                                              -> IfM lcl ModIface
        -- ^ Modify an interface that have been loaded. This is called by
        -- "GHC.Iface.Load" when an interface is successfully loaded. Not applied to
        -- the loading of the plugin interface. Tools that rely on information from
        -- modules other than the currently compiled one should implement this
        -- function.
      }

    -- Note [Source plugins]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- The `Plugin` datatype have been extended by fields that allow access to the
    -- different inner representations that are generated during the compilation
    -- process. These fields are `parsedResultAction`, `renamedResultAction`,
    -- `typeCheckResultAction`, `spliceRunAction` and `interfaceLoadAction`.
    --
    -- The main purpose of these plugins is to help tool developers. They allow
    -- development tools to extract the information about the source code of a big
    -- Haskell project during the normal build procedure. In this case the plugin
    -- acts as the tools access point to the compiler that can be controlled by
    -- compiler flags. This is important because the manipulation of compiler flags
    -- is supported by most build environment.
    --
    -- For the full discussion, check the full proposal at:
    -- https://gitlab.haskell.org/ghc/ghc/wikis/extended-plugins-proposal

    data PluginWithArgs = PluginWithArgs
      { PluginWithArgs -> Plugin
    paPlugin :: Plugin
        -- ^ the actual callable plugin
      , PluginWithArgs -> [CommandLineOption]
    paArguments :: [CommandLineOption]
        -- ^ command line arguments for the plugin
      }

    -- | A plugin with its arguments. The result of loading the plugin.
    data LoadedPlugin = LoadedPlugin
      { LoadedPlugin -> PluginWithArgs
    lpPlugin :: PluginWithArgs
      -- ^ the actual plugin together with its commandline arguments
      , LoadedPlugin -> ModIface
    lpModule :: ModIface
      -- ^ the module containing the plugin
      }

    -- | A static plugin with its arguments. For registering compiled-in plugins
    -- through the GHC API.
    data StaticPlugin = StaticPlugin
      { StaticPlugin -> PluginWithArgs
    spPlugin :: PluginWithArgs
      -- ^ the actual plugin together with its commandline arguments
      }

    lpModuleName :: LoadedPlugin -> ModuleName
    lpModuleName :: LoadedPlugin -> ModuleName
    lpModuleName = forall unit. GenModule unit -> ModuleName
    moduleName forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall (phase :: ModIfacePhase). ModIface_ phase -> GenModule Unit
    mi_module forall b c a. (b -> c) -> (a -> b) -> a -> c
    . LoadedPlugin -> ModIface
    lpModule

    pluginRecompile' :: PluginWithArgs -> IO PluginRecompile
    pluginRecompile' :: PluginWithArgs -> IO PluginRecompile
    pluginRecompile' (PluginWithArgs Plugin
    plugin [CommandLineOption]
    args) = Plugin -> [CommandLineOption] -> IO PluginRecompile
    pluginRecompile Plugin
    plugin [CommandLineOption]
    args

    data PluginRecompile = ForceRecompile | NoForceRecompile | MaybeRecompile Fingerprint

    instance Outputable PluginRecompile where
      ppr :: PluginRecompile -> SDoc
    ppr PluginRecompile
    ForceRecompile = CommandLineOption -> SDoc
    text CommandLineOption
    "ForceRecompile"
      ppr PluginRecompile
    NoForceRecompile = CommandLineOption -> SDoc
    text CommandLineOption
    "NoForceRecompile"
      ppr (MaybeRecompile Fingerprint
    fp) = CommandLineOption -> SDoc
    text CommandLineOption
    "MaybeRecompile" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr Fingerprint
    fp

    instance Semigroup PluginRecompile where
      PluginRecompile
    ForceRecompile <> :: PluginRecompile -> PluginRecompile -> PluginRecompile
    <> PluginRecompile
    _ = PluginRecompile
    ForceRecompile
      PluginRecompile
    NoForceRecompile <> PluginRecompile
    r = PluginRecompile
    r
      MaybeRecompile Fingerprint
    fp <> PluginRecompile
    NoForceRecompile   = Fingerprint -> PluginRecompile
    MaybeRecompile Fingerprint
    fp
      MaybeRecompile Fingerprint
    fp <> MaybeRecompile Fingerprint
    fp' = Fingerprint -> PluginRecompile
    MaybeRecompile ([Fingerprint] -> Fingerprint
    fingerprintFingerprints [Fingerprint
    fp, Fingerprint
    fp'])
      MaybeRecompile Fingerprint
    _fp <> PluginRecompile
    ForceRecompile     = PluginRecompile
    ForceRecompile

    instance Monoid PluginRecompile where
      mempty :: PluginRecompile
    mempty = PluginRecompile
    NoForceRecompile

    type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]
    type TcPlugin = [CommandLineOption] -> Maybe GHC.Tc.Types.TcPlugin
    type HoleFitPlugin = [CommandLineOption] -> Maybe HoleFitPluginR

    purePlugin, impurePlugin, flagRecompile :: [CommandLineOption] -> IO PluginRecompile
    purePlugin :: [CommandLineOption] -> IO PluginRecompile
    purePlugin [CommandLineOption]
    _args = forall (m :: * -> *) a. Monad m => a -> m a
    return PluginRecompile
    NoForceRecompile

    impurePlugin :: [CommandLineOption] -> IO PluginRecompile
    impurePlugin [CommandLineOption]
    _args = forall (m :: * -> *) a. Monad m => a -> m a
    return PluginRecompile
    ForceRecompile

    flagRecompile :: [CommandLineOption] -> IO PluginRecompile
    flagRecompile =
      forall (m :: * -> *) a. Monad m => a -> m a
    return forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Fingerprint -> PluginRecompile
    MaybeRecompile forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Fingerprint] -> Fingerprint
    fingerprintFingerprints forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a b. (a -> b) -> [a] -> [b]
    map CommandLineOption -> Fingerprint
    fingerprintString forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. Ord a => [a] -> [a]
    sort

    -- | Default plugin: does nothing at all, except for marking that safe
    -- inference has failed unless @-fplugin-trustworthy@ is passed. For
    -- compatibility reason you should base all your plugin definitions on this
    -- default value.
    defaultPlugin :: Plugin
    defaultPlugin :: Plugin
    defaultPlugin = Plugin {
            installCoreToDos :: CorePlugin
    installCoreToDos      = forall a b. a -> b -> a
    const forall (m :: * -> *) a. Monad m => a -> m a
    return
          , tcPlugin :: TcPlugin
    tcPlugin              = forall a b. a -> b -> a
    const forall a. Maybe a
    Nothing
          , holeFitPlugin :: HoleFitPlugin
    holeFitPlugin         = forall a b. a -> b -> a
    const forall a. Maybe a
    Nothing
          , driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
    driverPlugin          = forall a b. a -> b -> a
    const forall (m :: * -> *) a. Monad m => a -> m a
    return
          , pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
    pluginRecompile       = [CommandLineOption] -> IO PluginRecompile
    impurePlugin
          , renamedResultAction :: [CommandLineOption]
    -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
    renamedResultAction   = \[CommandLineOption]
    _ TcGblEnv
    env HsGroup GhcRn
    grp -> forall (m :: * -> *) a. Monad m => a -> m a
    return (TcGblEnv
    env, HsGroup GhcRn
    grp)
          , parsedResultAction :: [CommandLineOption]
    -> ModSummary -> HsParsedModule -> Hsc HsParsedModule
    parsedResultAction    = \[CommandLineOption]
    _ ModSummary
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return
          , typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
    typeCheckResultAction = \[CommandLineOption]
    _ ModSummary
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return
          , spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
    spliceRunAction       = \[CommandLineOption]
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return
          , interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
    interfaceLoadAction   = \[CommandLineOption]
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return
        }

    -- | A renamer plugin which mades the renamed source available in
    -- a typechecker plugin.
    keepRenamedSource :: [CommandLineOption] -> TcGblEnv
                      -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
    keepRenamedSource :: [CommandLineOption]
    -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
    keepRenamedSource [CommandLineOption]
    _ TcGblEnv
    gbl_env HsGroup GhcRn
    group =
      forall (m :: * -> *) a. Monad m => a -> m a
    return (TcGblEnv
    gbl_env { tcg_rn_decls :: Maybe (HsGroup GhcRn)
    tcg_rn_decls = forall {p :: Pass}.
    Maybe (HsGroup (GhcPass p)) -> Maybe (HsGroup (GhcPass p))
    update (TcGblEnv -> Maybe (HsGroup GhcRn)
    tcg_rn_decls TcGblEnv
    gbl_env)
                      , tcg_rn_exports :: Maybe [(LIE GhcRn, Avails)]
    tcg_rn_exports = forall {a}. Maybe [a] -> Maybe [a]
    update_exports (TcGblEnv -> Maybe [(LIE GhcRn, Avails)]
    tcg_rn_exports TcGblEnv
    gbl_env) }, HsGroup GhcRn
    group)
      where
        update_exports :: Maybe [a] -> Maybe [a]
    update_exports Maybe [a]
    Nothing = forall a. a -> Maybe a
    Just []
        update_exports Maybe [a]
    m = Maybe [a]
    m

        update :: Maybe (HsGroup (GhcPass p)) -> Maybe (HsGroup (GhcPass p))
    update Maybe (HsGroup (GhcPass p))
    Nothing = forall a. a -> Maybe a
    Just forall (p :: Pass). HsGroup (GhcPass p)
    emptyRnGroup
        update Maybe (HsGroup (GhcPass p))
    m       = Maybe (HsGroup (GhcPass p))
    m

    type PluginOperation m a = Plugin -> [CommandLineOption] -> a -> m a
    type ConstPluginOperation m a = Plugin -> [CommandLineOption] -> a -> m ()

    plugins :: HscEnv -> [PluginWithArgs]
    plugins :: HscEnv -> [PluginWithArgs]
    plugins HscEnv
    hsc_env =
      forall a b. (a -> b) -> [a] -> [b]
    map LoadedPlugin -> PluginWithArgs
    lpPlugin (HscEnv -> [LoadedPlugin]
    hsc_plugins HscEnv
    hsc_env) forall a. [a] -> [a] -> [a]
    ++
      forall a b. (a -> b) -> [a] -> [b]
    map StaticPlugin -> PluginWithArgs
    spPlugin (HscEnv -> [StaticPlugin]
    hsc_static_plugins HscEnv
    hsc_env)

    -- | Perform an operation by using all of the plugins in turn.
    withPlugins :: Monad m => HscEnv -> PluginOperation m a -> a -> m a
    withPlugins :: forall (m :: * -> *) a.
    Monad m =>
    HscEnv -> PluginOperation m a -> a -> m a
    withPlugins HscEnv
    hsc_env PluginOperation m a
    transformation a
    input = forall (t :: * -> *) (m :: * -> *) b a.
    (Foldable t, Monad m) =>
    (b -> a -> m b) -> b -> t a -> m b
    foldM a -> PluginWithArgs -> m a
    go a
    input (HscEnv -> [PluginWithArgs]
    plugins HscEnv
    hsc_env)
      where
        go :: a -> PluginWithArgs -> m a
    go a
    arg (PluginWithArgs Plugin
    p [CommandLineOption]
    opts) = PluginOperation m a
    transformation Plugin
    p [CommandLineOption]
    opts a
    arg

    mapPlugins :: HscEnv -> (Plugin -> [CommandLineOption] -> a) -> [a]
    mapPlugins :: forall a. HscEnv -> (Plugin -> [CommandLineOption] -> a) -> [a]
    mapPlugins HscEnv
    hsc_env Plugin -> [CommandLineOption] -> a
    f = forall a b. (a -> b) -> [a] -> [b]
    map (\(PluginWithArgs Plugin
    p [CommandLineOption]
    opts) -> Plugin -> [CommandLineOption] -> a
    f Plugin
    p [CommandLineOption]
    opts) (HscEnv -> [PluginWithArgs]
    plugins HscEnv
    hsc_env)

    -- | Perform a constant operation by using all of the plugins in turn.
    withPlugins_ :: Monad m => HscEnv -> ConstPluginOperation m a -> a -> m ()
    withPlugins_ :: forall (m :: * -> *) a.
    Monad m =>
    HscEnv -> ConstPluginOperation m a -> a -> m ()
    withPlugins_ HscEnv
    hsc_env ConstPluginOperation m a
    transformation a
    input
      = forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (\(PluginWithArgs Plugin
    p [CommandLineOption]
    opts) -> ConstPluginOperation m a
    transformation Plugin
    p [CommandLineOption]
    opts a
    input)
              (HscEnv -> [PluginWithArgs]
    plugins HscEnv
    hsc_env)

    type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()
    data FrontendPlugin = FrontendPlugin {
          FrontendPlugin -> FrontendPluginAction
    frontend :: FrontendPluginAction
        }
    defaultFrontendPlugin :: FrontendPlugin
    defaultFrontendPlugin :: FrontendPlugin
    defaultFrontendPlugin = FrontendPlugin { frontend :: FrontendPluginAction
    frontend = \[CommandLineOption]
    _ [(CommandLineOption, Maybe Phase)]
    _ -> forall (m :: * -> *) a. Monad m => a -> m a
    return () }