Remove calls to resolve_tools

Replace them mostly with `FilesToRunProvider`s. For cc_wrapper, where
repl's also need the runfiles, use a struct that has the executable, the
`FilesToRunProvider` and the runfiles. The executable could be retrieved
from the `FilesToRunProvider`, but it is more convenient to just have it
in the struct.

Remove outdated comment about re-enabling resolve_tools for bazel 8

Author: iteratee

README.md

@@ -27,10 +27,6 @@ You'll need [Bazel >= 6.0][bazel-getting-started] installed.
 
 If you are on NixOS, skip to the [Nixpkgs](#Nixpkgs) section.
 
-> [!NOTE]
-> Bazel 8 users will need to add
-> `common --noincompatible_disallow_ctx_resolve_tools` to `.bazelrc`
-
 ### System dependencies
 
 Refer to the "Before you begin" section in [the documentation](docs/haskell.rst).

haskell/c2hs.bzl

@@ -31,7 +31,6 @@ def _c2hs_library_impl(ctx):
     )
     args = hs.actions.args()
     c2hs = ctx.toolchains["@rules_haskell//haskell/c2hs:toolchain"].c2hs
-    c2hs_exe = ctx.toolchains["@rules_haskell//haskell/c2hs:toolchain"].c2hs_exe
 
     if len(ctx.files.srcs) != 1:
         fail("srcs field should contain exactly one file.")
@@ -44,7 +43,7 @@ def _c2hs_library_impl(ctx):
     args.add_all([chs_file.path, "-o", hs_file.path])
 
     args.add("-C-E")
-    args.add_all(["--cpp", cc.tools.cc])
+    args.add_all(["--cpp", cc.tools.cc.executable.path])
     args.add("-C-includeghcplatform.h")
     args.add("-C-includeghcversion.h")
     args.add_all(["-C" + x for x in cc.cpp_flags])
@@ -70,21 +69,16 @@ def _c2hs_library_impl(ctx):
         (version_macro_headers, version_macro_flags) = version_macro_includes(dep_info)
         args.add_all(["-C" + x for x in version_macro_flags])
 
-    (inputs, input_manifests) = ctx.resolve_tools(tools = [c2hs])
-
     hs.actions.run_shell(
         inputs = depset(transitive = [
             depset(cc.hdrs),
             depset([chs_file]),
             depset(dep_chi_files),
-            depset(cc.files),
             depset(hs.toolchain.bindir),
             depset(hs.toolchain.libdir),
             set.to_depset(version_macro_headers),
-            inputs,
         ]),
-        input_manifests = input_manifests,
-        tools = [hs.tools.ghc_pkg, c2hs_exe],
+        tools = [hs.tools.ghc_pkg, c2hs, cc.tools.cc.as_tool],
         outputs = [hs_file, chi_file],
         command =
             # cpp (called via c2hs) gets very unhappy if the mingw bin dir is
@@ -103,7 +97,7 @@ def _c2hs_library_impl(ctx):
         {c2hs} "${{include_dirs_args[@]}}" "$@"
         """.format(
                 ghc_pkg = hs.tools.ghc_pkg.path,
-                c2hs = c2hs_exe.path,
+                c2hs = c2hs.executable.path,
             ),
         mnemonic = "HaskellC2Hs",
         arguments = [args],
@@ -159,12 +153,10 @@ def _c2hs_toolchain_impl(ctx):
     return [
         platform_common.ToolchainInfo(
             name = ctx.label.name,
-            # We have both c2hs which points to the target and c2hs_exe
-            # which points to the file. The former is used to collect
-            # runfiles while the latter is used to get the path to
-            # c2hs.
-            c2hs = ctx.attr.c2hs,
-            c2hs_exe = ctx.executable.c2hs,
+            # Get a FilesToRunProvider which can be used to insert all the
+            # necessary files for the tool into the environment of an action
+            # run.
+            c2hs = ctx.attr.c2hs[DefaultInfo].files_to_run,
         ),
     ]
 

haskell/cabal.bzl

@@ -161,7 +161,7 @@ def _cabal_toolchain_info(hs, cc, workspace_name, runghc):
         hsc2hs = hs.tools.hsc2hs.path,
         runghc = runghc.path,
         ar = ar,
-        cc = cc.tools.cc,
+        cc = cc.tools.cc.executable.path,
         ld = cc.tools.ld,
         strip = cc.tools.strip,
         is_windows = hs.toolchain.is_windows,
@@ -179,8 +179,6 @@ def _prepare_cabal_inputs(
         direct_cc_info,
         component,
         package_id,
-        tool_inputs,
-        tool_input_manifests,
         cabal,
         setup,
         setup_deps,
@@ -252,7 +250,7 @@ def _prepare_cabal_inputs(
     env = dicts.add(hs.env, cc.env)
     env["PATH"] = join_path_list(
         hs.toolchain.is_windows,
-        _binary_paths(tool_inputs) + posix.paths + hs.tools_config.path_for_cabal,
+        posix.paths + hs.tools_config.path_for_cabal,
     )
     if hs.toolchain.is_darwin:
         env["SDKROOT"] = "macosx"  # See haskell/private/actions/link.bzl
@@ -348,7 +346,6 @@ def _prepare_cabal_inputs(
     extra_ldflags_file = darwin_flags_for_linking_indirect_cc_deps(hs, cc, posix, hs.name, dynamic = True)
 
     # Redundant with _binary_paths() above, but better be explicit when we can.
-    path_args.extend([_cabal_tool_flag(tool_flag) for tool_flag in tool_inputs.to_list() if _cabal_tool_flag(tool_flag)])
 
     repo_name = "_main"
     if generate_paths_module and label and label.repo_name:
@@ -389,7 +386,6 @@ def _prepare_cabal_inputs(
         input_files,
         transitive = [
             depset(srcs),
-            depset(cc.files),
             depset(ghc_files),
             package_databases,
             setup_dep_info.package_databases,
@@ -402,18 +398,14 @@ def _prepare_cabal_inputs(
             setup_dep_info.hs_libraries,
             dep_info.interface_dirs,
             dep_info.hs_libraries,
-            tool_inputs,
         ],
     )
-    input_manifests = tool_input_manifests + hs.toolchain.cc_wrapper.manifests
-
     runfiles_direct = runfiles_libs if static_binary else dynamic_libs
 
     return struct(
         cabal_wrapper = cabal_wrapper,
         args = args,
         inputs = inputs,
-        input_manifests = input_manifests,
         env = env,
         runfiles = depset(direct = runfiles_direct),
     )
@@ -575,7 +567,7 @@ def _haskell_cabal_library_impl(ctx):
                 ),
                 sibling = cabal,
             )
-    (tool_inputs, tool_input_manifests) = ctx.resolve_tools(tools = ctx.attr.tools)
+    attr_tools = [tool[DefaultInfo].files_to_run for tool in ctx.attr.tools]
     c = _prepare_cabal_inputs(
         hs,
         cc,
@@ -586,8 +578,6 @@ def _haskell_cabal_library_impl(ctx):
         direct_cc_info,
         component = "lib:{}".format(ctx.attr.sublibrary_name or ctx.attr.package_name or hs.label.name),
         package_id = package_id,
-        tool_inputs = tool_inputs,
-        tool_input_manifests = tool_input_manifests,
         cabal = cabal,
         setup = setup,
         setup_deps = setup_deps,
@@ -620,15 +610,23 @@ def _haskell_cabal_library_impl(ctx):
     if with_profiling:
         outputs.append(profiling_library)
 
-    (_, runghc_manifest) = ctx.resolve_tools(tools = [ctx.attr._runghc])
     json_args = ctx.actions.declare_file("{}_cabal_wrapper_args.json".format(ctx.label.name))
     ctx.actions.write(json_args, json.encode(c.args))
+
+    # Ensure that dependent tools can be found.
+    paths = []
+    if "PATH" in c.env:
+        paths.append(c.env["PATH"])
+    paths.extend([t.executable.dirname for t in attr_tools])
+    c.env["PATH"] = ":".join(paths)
+
     ctx.actions.run(
         executable = c.cabal_wrapper,
         arguments = [json_args.path],
         inputs = depset([json_args], transitive = [c.inputs]),
-        input_manifests = c.input_manifests + runghc_manifest,
-        tools = [c.cabal_wrapper, ctx.executable._runghc] + hs.tools_config.tools_for_ghc,
+        tools = attr_tools +
+                [c.cabal_wrapper, ctx.executable._runghc, hs.toolchain.cc_wrapper.as_tool] +
+                hs.tools_config.tools_for_ghc,
         outputs = outputs,
         env = c.env,
         mnemonic = "HaskellCabalLibrary",
@@ -911,7 +909,7 @@ def _haskell_cabal_binary_impl(ctx):
         "_install/{}_data".format(hs.label.name),
         sibling = cabal,
     )
-    (tool_inputs, tool_input_manifests) = ctx.resolve_tools(tools = ctx.attr.tools)
+    attr_tools = [tool[DefaultInfo].files_to_run for tool in ctx.attr.tools]
     c = _prepare_cabal_inputs(
         hs,
         cc,
@@ -922,8 +920,6 @@ def _haskell_cabal_binary_impl(ctx):
         direct_cc_info,
         component = "exe:{}".format(exe_name),
         package_id = hs.label.name,
-        tool_inputs = tool_inputs,
-        tool_input_manifests = tool_input_manifests,
         cabal = cabal,
         setup = setup,
         setup_deps = setup_deps,
@@ -942,20 +938,20 @@ def _haskell_cabal_binary_impl(ctx):
         static_binary = static_binary,
         label = ctx.label,
     )
-    (_, runghc_manifest) = ctx.resolve_tools(tools = [ctx.attr._runghc])
     json_args = ctx.actions.declare_file("{}_cabal_wrapper_args.json".format(ctx.label.name))
     ctx.actions.write(json_args, json.encode(c.args))
     ctx.actions.run(
         executable = c.cabal_wrapper,
         arguments = [json_args.path],
         inputs = depset([json_args], transitive = [c.inputs]),
-        input_manifests = c.input_manifests + runghc_manifest,
         outputs = [
             package_database,
             binary,
             data_dir,
         ],
-        tools = [c.cabal_wrapper, ctx.executable._runghc] + hs.tools_config.tools_for_ghc,
+        tools = attr_tools +
+                [c.cabal_wrapper, ctx.executable._runghc, hs.toolchain.cc_wrapper.as_tool] +
+                hs.tools_config.tools_for_ghc,
         env = c.env,
         mnemonic = "HaskellCabalBinary",
         progress_message = "HaskellCabalBinary {}".format(hs.label),

haskell/cc.bzl

@@ -118,13 +118,10 @@ def cc_interop_info(ctx, override_cc_toolchain = None):
     # Generate cc wrapper script on Darwin that adjusts load commands.
     hs_toolchain = ctx.toolchains["@rules_haskell//haskell:toolchain"]
     cc_wrapper = hs_toolchain.cc_wrapper
-    cc = cc_wrapper.executable.path
-    cc_files = depset(transitive = [cc_toolchain.all_files, cc_wrapper.inputs])
-    cc_manifests = cc_wrapper.manifests
 
     tools = {
         "ar": cc_toolchain.ar_executable,
-        "cc": cc,
+        "cc": cc_wrapper,
         "ld": cc_toolchain.ld_executable,
         "cpp": cc_toolchain.preprocessor_executable,
         "nm": cc_toolchain.nm_executable,
@@ -163,8 +160,6 @@ def cc_interop_info(ctx, override_cc_toolchain = None):
     return CcInteropInfo(
         tools = struct(**tools),
         env = env,
-        files = cc_files.to_list(),
-        manifests = cc_manifests,
         hdrs = hdrs.to_list(),
         cpp_flags = cpp_flags,
         include_args = include_args,

haskell/doctest.bzl

@@ -98,7 +98,7 @@ def _haskell_doctest_single(target, ctx):
         ctx,
         override_cc_toolchain = hs.tools_config.maybe_exec_cc_toolchain,
     )
-    args.add_all(ghc_cc_program_args(hs, cc.tools.cc, cc.tools.ld))
+    args.add_all(ghc_cc_program_args(hs, cc.tools.cc.executable.path, cc.tools.ld))
 
     doctest_log = ctx.actions.declare_file(
         "doctest-log-" + ctx.label.name + "-" + target.label.name,
@@ -137,7 +137,6 @@ def _haskell_doctest_single(target, ctx):
             depset(get_ghci_library_files(hs, cc_libraries_info, cc.transitive_libraries)),
             depset(
                 toolchain.doctest +
-                cc.files +
                 [hs.tools.ghc],
             ),
         ]),
@@ -173,6 +172,7 @@ def _haskell_doctest_single(target, ctx):
             # sandboxing altogether for doctest tests.
             "no-sandbox": "1",
         },
+        tools = [cc.tools.cc.as_tool],
     )
     return doctest_log
 

haskell/experimental/private/module.bzl

@@ -21,10 +21,6 @@ load(
 )
 load("//haskell:private/path_utils.bzl", "infer_main_module")
 load("//haskell:private/pkg_id.bzl", "pkg_id")
-load(
-    "//haskell:private/plugins.bzl",
-    "resolve_plugin_tools",
-)
 load(
     "//haskell:providers.bzl",
     "GhcPluginInfo",
@@ -173,8 +169,9 @@ def _build_haskell_module(
         module_attr.name,
         [dep for plugin in plugin_decl for dep in plugin[GhcPluginInfo].deps],
     )
-    plugins = [resolve_plugin_tools(ctx, plugin[GhcPluginInfo]) for plugin in plugin_decl]
-    (preprocessors_inputs, preprocessors_input_manifests) = ctx.resolve_tools(tools = ctx.attr.tools + module_attr.tools)
+    plugin_infos = [plugin[GhcPluginInfo] for plugin in plugin_decl]
+    plugin_tools = [tool[DefaultInfo].files_to_run for i in plugin_infos for tool in i.tools]
+    attr_tools = [tool[DefaultInfo].files_to_run for tool in (ctx.attr.tools + module_attr.tools)]
 
     # TODO[AH] Support additional outputs such as `.hie`.
 
@@ -254,7 +251,7 @@ def _build_haskell_module(
 
     args.add_all(cc.include_args)
 
-    if plugins or enable_th:
+    if plugin_infos or enable_th:
         # cc toolchain linker flags would be necessary when the interpreter wants to
         # load any libraries
         args.add_all(cc.linker_flags, format_each = "-optl%s")
@@ -278,8 +275,8 @@ def _build_haskell_module(
         plugin_pkg_info = expose_packages(
             package_ids = [
                 pkg_id
-                for plugin in plugins
-                for pkg_id in all_dependencies_package_ids(plugin.deps)
+                for plugin_info in plugin_infos
+                for pkg_id in all_dependencies_package_ids(plugin_info.deps)
             ],
             package_databases = plugin_dep_info.package_databases,
             version = version,
@@ -288,17 +285,10 @@ def _build_haskell_module(
     )
     args.add_all(pkg_info_args)
 
-    for plugin in plugins:
-        args.add("-fplugin={}".format(plugin.module))
-        for opt in plugin.args:
-            args.add_all(["-fplugin-opt", "{}:{}".format(plugin.module, opt)])
-
-    plugin_tool_inputs = depset(transitive = [plugin.tool_inputs for plugin in plugins])
-    plugin_tool_input_manifests = [
-        manifest
-        for plugin in plugins
-        for manifest in plugin.tool_input_manifests
-    ]
+    for plugin_info in plugin_infos:
+        args.add("-fplugin={}".format(plugin_info.module))
+        for opt in plugin_info.args:
+            args.add_all(["-fplugin-opt", "{}:{}".format(plugin_info.module, opt)])
 
     args.add_all(hs.toolchain.ghcopts)
     args.add_all(user_ghcopts)
@@ -310,7 +300,7 @@ def _build_haskell_module(
         args.add(paths.join(ar_bindir, "otool"), format = "-pgmotool=%s")
         args.add(paths.join(ar_bindir, "install_name_tool"), format = "-pgminstall_name_tool=%s")
 
-    if plugins and not enable_th:
+    if plugin_infos and not enable_th:
         # For #1681. These suppresses bogus warnings about missing libraries which
         # aren't really needed.
         args.add("-Wno-missed-extra-shared-lib")
@@ -345,8 +335,6 @@ def _build_haskell_module(
                 plugin_dep_info.package_databases,
                 plugin_dep_info.interface_dirs,
                 plugin_dep_info.hs_libraries,
-                plugin_tool_inputs,
-                preprocessors_inputs,
                 interface_inputs,
                 abi_inputs,
             ] + [
@@ -361,7 +349,6 @@ def _build_haskell_module(
                 if enable_th
             ],
         ),
-        input_manifests = preprocessors_input_manifests + plugin_tool_input_manifests,
         outputs = outputs,
         mnemonic = "HaskellBuildObject" + ("Prof" if with_profiling else ""),
         progress_message = "HaskellBuildObject {} {}".format(hs.label, module.label),
@@ -371,6 +358,7 @@ def _build_haskell_module(
         extra_name = module.label.package.replace("/", "_") + "_" + module.label.name,
         hi_file = module_outputs.hi,
         abi_file = module_outputs.abi,
+        extra_tools = attr_tools + plugin_tools,
     )
 
     is_boot = _is_boot(src.path)