text: load(":providers.bzl", "GhcPluginInfo", "HaskellLibraryInfo")
  
  def ghc_plugin_impl(ctx):
      args = ctx.attr.args
      args = [ctx.expand_location(arg, ctx.attr.tools) for arg in args]
      args = [ctx.expand_make_variables("args", arg, {}) for arg in args]
  
      # XXX Ideally we'd resolve tools downstream.
      (tool_inputs, tool_input_manifests) = ctx.resolve_tools(tools = ctx.attr.tools)
      return [
          GhcPluginInfo(
              module = ctx.attr.module,
              deps = ctx.attr.deps,
              tool_inputs = tool_inputs,
              tool_input_manifests = tool_input_manifests,
              args = args,
          ),
      ]
  
  ghc_plugin = rule(
      ghc_plugin_impl,
      attrs = {
          "module": attr.string(
              doc = "Plugin entrypoint.",
          ),
          "deps": attr.label_list(
              doc = "Plugin dependencies. These are compile-time dependencies only.",
              providers = [HaskellLibraryInfo],
          ),
          "args": attr.string_list(
              doc = "Plugin options.",
          ),
          "tools": attr.label_list(
              doc = "Tools needed by the plugin when it used.",
          ),
      },
  )
  """Declare a GHC plugin.
  
  Example:
    ```bzl
    haskell_library(
        name = "plugin-lib",
        srcs = ["Plugin.hs"],
    )
  
    ghc_plugin(
        name = "plugin",
        module = "Plugin",
        deps = [":plugin-lib"],
    )
  
    haskell_binary(
        name = "some-binary",
        srcs = ["Main.hs"],
        plugins = [":plugin"],
    ```
  
  Plugins to use during compilation by GHC are given by the `plugins`
  attribute to Haskell rules. Plugins are haskell libraries with some
  extra metadata, like the name of the module that acts as the
  entrypoint for the plugin and plugin options.
  
  """
  