diff --git a/MODULE.bazel b/MODULE.bazel index a61f3cc83..1c5882959 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -5,7 +5,7 @@ module( bazel_dep( name = "platforms", - version = "0.0.8", + version = "0.0.10", ) bazel_dep( name = "rules_java", @@ -15,14 +15,28 @@ bazel_dep( name = "rules_license", version = "1.0.0", ) +bazel_dep( + name = "abseil-cpp", + version = "20240116.3", +) bazel_dep( name = "protobuf", - version = "21.7", + version = "27.0", repo_name = "com_google_protobuf", ) + +# workaround build problems on Windows +single_version_override( + module_name = "protobuf", + patch_strip = 1, + # see https://github.com/protocolbuffers/protobuf/issues/16844 + # TODO: remove for protobuf version >= 31.0 + patches = ["//haskell:private/com_google_protobuf-protoc-dbghlp.diff"], +) + bazel_dep( name = "rules_cc", - version = "0.0.9", + version = "0.0.15", ) bazel_dep( name = "rules_nodejs", @@ -38,7 +52,7 @@ bazel_dep( ) bazel_dep( name = "bazel_skylib", - version = "1.5.0", + version = "1.7.1", ) bazel_dep( name = "rules_proto", @@ -196,7 +210,7 @@ register_toolchains( # For buildifier bazel_dep( name = "rules_go", - version = "0.39.1", + version = "0.41.0", dev_dependency = True, repo_name = "io_bazel_rules_go", ) @@ -240,13 +254,6 @@ go_deps.module( use_repo( go_deps, "com_github_gogo_protobuf", - "com_github_golang_mock", - "com_github_golang_protobuf", - "org_golang_google_genproto", - "org_golang_google_grpc", - "org_golang_google_protobuf", - "org_golang_x_net", - "org_golang_x_tools", ) # For documentation diff --git a/WORKSPACE b/WORKSPACE index e11dabb35..0d7779d9d 100755 --- a/WORKSPACE +++ b/WORKSPACE @@ -49,6 +49,12 @@ load("@rules_proto//proto:toolchains.bzl", "rules_proto_toolchains") rules_proto_toolchains() +load("@rules_java//java:repositories.bzl", "rules_java_dependencies", "rules_java_toolchains") + +rules_java_dependencies() + +rules_java_toolchains() + # For buildifier http_archive( name = "io_bazel_rules_go", diff --git a/buildifier/BUILD.bazel b/buildifier/BUILD.bazel index 6f3c3114e..8f08a1c35 100644 --- a/buildifier/BUILD.bazel +++ b/buildifier/BUILD.bazel @@ -9,15 +9,6 @@ _lint_warnings = [ "-function-docstring-args", # TODO "-function-docstring-header", # TODO "-function-docstring-return", # TODO - "-native-cc-common", - "-native-cc-info", - "-native-cc-library", - "-native-cc-shared-library-info", - "-native-java-common", - "-native-java-info", - "-native-proto", - "-native-proto-common", - "-native-proto-info", "-module-docstring", ] diff --git a/docs/BUILD.bazel b/docs/BUILD.bazel index 518ab88d4..0e5cbb7e1 100644 --- a/docs/BUILD.bazel +++ b/docs/BUILD.bazel @@ -24,16 +24,55 @@ set_site_end_location( }), ) -libraries = [ - "defs", - "toolchain", - "cabal", - "repositories", - "ghc_bindist", - "nixpkgs", - "protobuf", - "c2hs", -] +# +libraries = { + "defs": [ + "@com_google_protobuf//bazel:cc_proto_library_bzl", + "@com_google_protobuf//bazel/common:proto_info_bzl", + "@rules_cc//cc/common", + "@rules_cc//cc/toolchains:srcs", + "@rules_java//java:rules", + "@rules_shell//shell:rules_bzl", + "//haskell", + ], + "toolchain": [ + "@com_google_protobuf//bazel:cc_proto_library_bzl", + "@com_google_protobuf//bazel/common:proto_info_bzl", + "@rules_cc//cc/common", + "@rules_cc//cc/toolchains:srcs", + "@rules_java//java:rules", + "//haskell", + ], + "cabal": [ + "@com_google_protobuf//bazel:cc_proto_library_bzl", + "@com_google_protobuf//bazel/common:proto_info_bzl", + "@rules_cc//cc/common", + "@rules_cc//cc/toolchains:srcs", + "@rules_proto//proto:defs", + "//haskell", + ], + "repositories": ["//haskell"], + "ghc_bindist": [ + "@rules_cc//cc/common", + "//haskell", + ], + "nixpkgs": [":haskell_nix"], + "protobuf": [ + "@com_google_protobuf//bazel:cc_proto_library_bzl", + "@com_google_protobuf//bazel/common:proto_info_bzl", + "@rules_cc//cc/common", + "@rules_cc//cc/toolchains:srcs", + "@rules_java//java:rules", + "@rules_proto//proto:defs", + "//haskell", + ], + "c2hs": [ + "@com_google_protobuf//bazel:cc_proto_library_bzl", + "@rules_cc//cc/common", + "@rules_cc//cc/toolchains:srcs", + "//haskell", + ], +} # moved here so that //haskell is not dependent upon rules_nixpkgs_* bzl_library( @@ -59,11 +98,7 @@ bzl_library( provider_template = ":templates/metadata/provider.vm", rule_template = ":templates/metadata/rule.vm", tags = ["dont_test_on_windows"], - deps = [ - ":haskell_nix", - "//haskell", - "@rules_shell//shell:rules_bzl", - ], + deps = lib_deps, ), # Generate markdown API documentation. stardoc( @@ -76,11 +111,7 @@ bzl_library( provider_template = ":templates/markdown/provider.vm", rule_template = ":templates/markdown/rule.vm", tags = ["dont_test_on_windows"], - deps = [ - ":haskell_nix", - "//haskell", - "@rules_shell//shell:rules_bzl", - ], + deps = lib_deps, ), # Convert markdown to html. genrule( @@ -109,7 +140,8 @@ $(execpath //docs/pandoc) \ tools = ["//docs/pandoc"], ), ) - for lib in libraries + # + for lib, lib_deps in libraries.items() ] # Combine all API documentation metadata. diff --git a/examples/MODULE.bazel b/examples/MODULE.bazel index 8751775ea..14229de8b 100644 --- a/examples/MODULE.bazel +++ b/examples/MODULE.bazel @@ -7,6 +7,10 @@ bazel_dep( name = "rules_nixpkgs_core", version = "0.13.0", ) +bazel_dep( + name = "rules_nixpkgs_cc", + version = "0.13.0", +) bazel_dep( name = "rules_haskell_nix", version = "1.0", @@ -27,7 +31,7 @@ bazel_dep( bazel_dep( name = "rules_cc", - version = "0.0.9", + version = "0.1.1", ) bazel_dep( name = "rules_sh", @@ -43,11 +47,19 @@ non_module_deps = use_extension(":non_module_deps.bzl", "non_module_deps") use_repo( non_module_deps, "Cabal", + "nixpkgs_config_cc", + "nixpkgs_config_cc_info", + "nixpkgs_config_cc_toolchains", + "nixpkgs_default", "os_info", "split", "zlib.hs", ) +register_toolchains( + "@nixpkgs_config_cc_toolchains//:all", +) + stack_snapshot = use_extension( "@rules_haskell//extensions:stack_snapshot.bzl", "stack_snapshot", diff --git a/examples/non_module_deps.bzl b/examples/non_module_deps.bzl index 8da21b457..8185cd832 100644 --- a/examples/non_module_deps.bzl +++ b/examples/non_module_deps.bzl @@ -2,11 +2,26 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") load("@rules_haskell//tools:os_info.bzl", "os_info") +load("@rules_nixpkgs_cc//:cc.bzl", "nixpkgs_cc_configure") +load("@rules_nixpkgs_core//:nixpkgs.bzl", "nixpkgs_local_repository") def repositories(*, bzlmod): # Some helpers for platform-dependent configuration os_info(name = "os_info") + nixpkgs_local_repository( + name = "nixpkgs_default", + nix_file = "@rules_haskell//nixpkgs:default.nix", + ) + + nixpkgs_cc_configure( + # Don't override the default cc toolchain needed for bindist mode. + name = "nixpkgs_config_cc", + repository = "@nixpkgs_default", + register = not bzlmod, + cc_std = "c++14", + ) + # For the cat_hs example. http_archive( name = "zlib.hs", diff --git a/haskell/BUILD.bazel b/haskell/BUILD.bazel index 99bace16c..a5fab3d60 100644 --- a/haskell/BUILD.bazel +++ b/haskell/BUILD.bazel @@ -61,22 +61,12 @@ bzl_library( ], ) -# @rules_cc//cc does not define a bzl_library itself, instead we define our -# own using the @rules_cc//cc:srcs filegroup. -bzl_library( - name = "rules_cc", - srcs = [ - "@rules_cc//cc:srcs", - ], -) - bzl_library( name = "haskell", srcs = glob(["**/*.bzl"]), visibility = ["//visibility:public"], deps = [ ":bazel_tools", - ":rules_cc", "//haskell/asterius:asterius_bzl", "//haskell/experimental:defs.bzl", "//haskell/experimental:providers.bzl", @@ -88,6 +78,7 @@ bzl_library( "@bazel_skylib//lib:shell", "@bazel_skylib//lib:versions", "@bazel_skylib//rules:expand_template", + "@rules_cc//cc:bzl_srcs", "@rules_sh//sh:posix", ], ) diff --git a/haskell/cabal.bzl b/haskell/cabal.bzl index a20204719..bd8bd387e 100644 --- a/haskell/cabal.bzl +++ b/haskell/cabal.bzl @@ -4,6 +4,7 @@ load("@bazel_skylib//lib:dicts.bzl", "dicts") load("@bazel_skylib//lib:paths.bzl", "paths") load("@bazel_skylib//lib:sets.bzl", "sets") load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe", "read_netrc", "use_netrc") +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain") load(":cc.bzl", "cc_interop_info", "ghc_cc_program_args") load(":haddock.bzl", "generate_unified_haddock_info") @@ -213,7 +214,7 @@ def _prepare_cabal_inputs( # already covered by their corresponding package-db entries. We only need # to add libraries and headers for direct C library dependencies to the # command line. - direct_libs = get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries) + direct_libs = get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries_direct) # The regular Haskell rules perform mostly static linking, i.e. where # possible all C library dependencies are linked statically. Cabal has no @@ -1508,7 +1509,7 @@ def _pin_packages(repository_ctx, resolved): ) hashes_url = "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/" + hashes_commit - resolved = dict(**resolved) + resolved = dict(resolved) for (_name, spec) in resolved.items(): # Determine package sha256 if spec["location"]["type"] == "hackage": diff --git a/haskell/cc.bzl b/haskell/cc.bzl index 8d0c0f30a..2f1df1452 100644 --- a/haskell/cc.bzl +++ b/haskell/cc.bzl @@ -9,7 +9,9 @@ load( "CPP_LINK_EXECUTABLE_ACTION_NAME", "C_COMPILE_ACTION_NAME", ) +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain") +load("@rules_cc//cc/common:cc_shared_library_info.bzl", "CcSharedLibraryInfo") load( "//haskell:providers.bzl", "HaskellInfo", @@ -31,7 +33,8 @@ CcInteropInfo = provider( "linker_flags": "Flags to forward to the linker", "include_args": "Extra include dirs", "cc_libraries_info": "HaskellCcLibrariesInfo", - "cc_libraries": "depset, C libraries from direct linking dependencies.", + "cc_libraries": "depset, C libraries from direct cc_library dependencies (deprecated, use cc_libraries_direct).", + "cc_libraries_direct": "depset, C libraries from direct dependencies, including cc_shared_library.", "transitive_libraries": "depset, C and Haskell libraries from transitive linking dependencies.", "plugin_libraries": "depset, C and Haskell libraries from transitive plugin dependencies.", "setup_libraries": "depset, C and Haskell libraries from Cabal setup dependencies.", @@ -50,6 +53,7 @@ def cc_interop_info(ctx, override_cc_toolchain = None): CcInteropInfo: Information needed for CC interop. """ ccs = [dep[CcInfo] for dep in ctx.attr.deps if CcInfo in dep and HaskellInfo not in dep] + cc_shared_libraries = [dep[CcSharedLibraryInfo] for dep in ctx.attr.deps if CcSharedLibraryInfo in dep] hdrs = [] include_args = [] @@ -160,6 +164,13 @@ def cc_interop_info(ctx, override_cc_toolchain = None): plugin_libraries = _transitive_libraries_from_attr(ctx, "plugins") setup_libraries = _transitive_libraries_from_attr(ctx, "setup_deps") + # Collect direct libraries from CcInfo only (for backward compatibility) + direct_libraries_from_cc_info = [lib for li in cc_common.merge_cc_infos(cc_infos = ccs).linking_context.linker_inputs.to_list() for lib in li.libraries] + + # Also include libraries from CcSharedLibraryInfo + direct_libraries_all = list(direct_libraries_from_cc_info) + direct_libraries_all.extend([lib for info in cc_shared_libraries for lib in info.linker_input.libraries]) + return CcInteropInfo( tools = struct(**tools), env = env, @@ -174,7 +185,8 @@ def cc_interop_info(ctx, override_cc_toolchain = None): # https://github.com/bazelbuild/bazel/issues/4571. linker_flags = linker_flags, cc_libraries_info = cc_libraries_info, - cc_libraries = get_cc_libraries(cc_libraries_info, [lib for li in cc_common.merge_cc_infos(cc_infos = ccs).linking_context.linker_inputs.to_list() for lib in li.libraries]), + cc_libraries = get_cc_libraries(cc_libraries_info, direct_libraries_from_cc_info), + cc_libraries_direct = get_cc_libraries(cc_libraries_info, direct_libraries_all), transitive_libraries = transitive_libraries, plugin_libraries = plugin_libraries, setup_libraries = setup_libraries, @@ -184,6 +196,7 @@ def ghc_cc_program_args(hs, cc, ld): """Returns the -pgm* flags required to override cc. Args: + hs: HaskellContext cc: string, path to the C compiler (cc_wrapper). ld: string, path to the linker (ld). diff --git a/haskell/cc_toolchain_config.bzl b/haskell/cc_toolchain_config.bzl index 90c53e1a6..0047738aa 100644 --- a/haskell/cc_toolchain_config.bzl +++ b/haskell/cc_toolchain_config.bzl @@ -10,6 +10,7 @@ load( "flag_set", "tool_path", ) +load("@rules_cc//cc:defs.bzl", "cc_common") def _impl(ctx): tool_paths = [ diff --git a/haskell/doctest.bzl b/haskell/doctest.bzl index 664cd61c9..befc8c630 100644 --- a/haskell/doctest.bzl +++ b/haskell/doctest.bzl @@ -2,6 +2,7 @@ load("@bazel_skylib//lib:dicts.bzl", "dicts") load("@bazel_skylib//lib:sets.bzl", "sets") +load("@rules_cc//cc:defs.bzl", "CcInfo") load("@rules_cc//cc:find_cc_toolchain.bzl", "use_cc_toolchain") load( "@rules_haskell//haskell:private/cc_libraries.bzl", @@ -114,7 +115,7 @@ def _haskell_doctest_single(target, ctx): # C library dependencies to link against. link_libraries( - get_ghci_library_files(hs, cc_libraries_info, cc.cc_libraries), + get_ghci_library_files(hs, cc_libraries_info, cc.cc_libraries_direct), args, prefix_optl = hs.toolchain.is_darwin, ) diff --git a/haskell/haddock.bzl b/haskell/haddock.bzl index a0e43a681..2e53eca12 100644 --- a/haskell/haddock.bzl +++ b/haskell/haddock.bzl @@ -2,6 +2,7 @@ load("@bazel_skylib//lib:paths.bzl", "paths") load("@bazel_skylib//lib:shell.bzl", "shell") +load("@rules_cc//cc:defs.bzl", "CcInfo") load( ":private/cc_libraries.bzl", "get_ghci_library_files", diff --git a/haskell/private/actions/compile.bzl b/haskell/private/actions/compile.bzl index a2203f1af..85dd53865 100644 --- a/haskell/private/actions/compile.bzl +++ b/haskell/private/actions/compile.bzl @@ -288,7 +288,7 @@ def _compilation_defaults( # Transitive library dependencies for runtime. link_libraries( - get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries, for_th_only = True), + get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries_direct, for_th_only = True), args, ) diff --git a/haskell/private/actions/info.bzl b/haskell/private/actions/info.bzl index fc970285b..9b74a6cf0 100644 --- a/haskell/private/actions/info.bzl +++ b/haskell/private/actions/info.bzl @@ -1,6 +1,7 @@ """Defines output groups that are consumed by tools such as 'hrepl'.""" load("@bazel_skylib//lib:paths.bzl", "paths") +load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") load(":private/cc_libraries.bzl", "get_ghci_library_files") def write_proto_file(hs, output_name, proto_type, content): @@ -157,7 +158,7 @@ def compile_info_output_groups( Returns: A dict whose keys are output groups and values are depsets of Files. """ - cc_libs = get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries) + cc_libs = get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries_direct) return { "haskell_cdep_libs": depset(cc_libs), "haskell_runfiles": runfiles, diff --git a/haskell/private/actions/package.bzl b/haskell/private/actions/package.bzl index 842b9eee5..0de96a5f8 100644 --- a/haskell/private/actions/package.bzl +++ b/haskell/private/actions/package.bzl @@ -24,7 +24,7 @@ def _get_extra_libraries(hs, cc, with_shared, dynamic = False): (cc_static_libs, cc_dynamic_libs) = get_library_files( hs, cc.cc_libraries_info, - cc.cc_libraries, + cc.cc_libraries_direct, pic = with_shared, dynamic = dynamic, ) diff --git a/haskell/private/actions/runghc.bzl b/haskell/private/actions/runghc.bzl index 2a5c4b53c..1f7a442a0 100644 --- a/haskell/private/actions/runghc.bzl +++ b/haskell/private/actions/runghc.bzl @@ -56,7 +56,7 @@ def build_haskell_runghc( args.append("-i{0}".format(idir)) link_libraries( - get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries), + get_ghci_library_files(hs, cc.cc_libraries_info, cc.cc_libraries_direct), args, ) diff --git a/haskell/private/cc_libraries.bzl b/haskell/private/cc_libraries.bzl index ba4089629..f98b9e5cb 100644 --- a/haskell/private/cc_libraries.bzl +++ b/haskell/private/cc_libraries.bzl @@ -6,6 +6,8 @@ providers. load("@bazel_skylib//lib:dicts.bzl", "dicts") load("@bazel_skylib//lib:paths.bzl", "paths") +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") +load("@rules_cc//cc/common:cc_shared_library_info.bzl", "CcSharedLibraryInfo") load( ":private/packages.bzl", "ghc_pkg_recache", diff --git a/haskell/private/cc_wrapper.bzl b/haskell/private/cc_wrapper.bzl index e1e217905..0d3ea2f6c 100644 --- a/haskell/private/cc_wrapper.bzl +++ b/haskell/private/cc_wrapper.bzl @@ -1,5 +1,6 @@ load("@bazel_skylib//lib:paths.bzl", "paths") load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES") +load("@rules_cc//cc:defs.bzl", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain") load("@rules_python//python:defs.bzl", "py_binary") load("@rules_shell//shell:sh_binary.bzl", "sh_binary") diff --git a/haskell/private/cc_wrapper_windows.sh.tpl b/haskell/private/cc_wrapper_windows.sh.tpl index 7f53b05d3..81a4a650e 100644 --- a/haskell/private/cc_wrapper_windows.sh.tpl +++ b/haskell/private/cc_wrapper_windows.sh.tpl @@ -131,6 +131,15 @@ add_arg() { # ---------------------------------------------------------- # Parse arguments +# Convert PWD to MSYS-style path for use with realpath. +# On Windows, PWD may be set to Windows-style (C:/...) by Bazel when invoking +# the cc_wrapper, even though the shell normally uses MSYS-style (/c/...). +PWD_FOR_REALPATH="$PWD" +if [[ "$PWD" =~ ^([A-Za-z]):(.*)$ ]]; then + # Convert C:/path to /c/path + PWD_FOR_REALPATH="/${BASH_REMATCH[1],,}${BASH_REMATCH[2]}" +fi + IN_RESPONSE_FILE=0 INCLUDE_DIR_COMING= INCLUDE_FLAG= @@ -154,7 +163,7 @@ shorten_path() { fi local relative - relative="$(realpath --relative-to="$PWD" "$shortest")" + relative="$(realpath --relative-to="$PWD_FOR_REALPATH" "$shortest")" if [[ ${#relative} -lt ${#shortest} ]]; then shortest="$relative" fi diff --git a/haskell/private/dependencies.bzl b/haskell/private/dependencies.bzl index 7a63aa45b..a0b7215e4 100644 --- a/haskell/private/dependencies.bzl +++ b/haskell/private/dependencies.bzl @@ -1,4 +1,5 @@ load("@bazel_skylib//lib:sets.bzl", "sets") +load("@rules_cc//cc:defs.bzl", "CcInfo") load( "//haskell:providers.bzl", "HaskellInfo", diff --git a/haskell/private/haskell_impl.bzl b/haskell/private/haskell_impl.bzl index e120d99c7..fcf818f50 100644 --- a/haskell/private/haskell_impl.bzl +++ b/haskell/private/haskell_impl.bzl @@ -5,7 +5,9 @@ load("@bazel_skylib//lib:dicts.bzl", "dicts") load("@bazel_skylib//lib:paths.bzl", "paths") load("@bazel_skylib//lib:sets.bzl", "sets") load("@bazel_skylib//lib:shell.bzl", "shell") +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain") +load("@rules_cc//cc/common:cc_shared_library_info.bzl", "CcSharedLibraryInfo") # buildifier: disable=bzl-visibility load("//haskell/experimental/private:module.bzl", "build_haskell_modules", "get_module_path_from_target") diff --git a/haskell/private/java.bzl b/haskell/private/java.bzl index 10fb81442..f4dbd9cf9 100644 --- a/haskell/private/java.bzl +++ b/haskell/private/java.bzl @@ -1,6 +1,7 @@ """Interop with Java.""" load("@bazel_skylib//lib:collections.bzl", "collections") +load("@rules_java//java:defs.bzl", "JavaInfo") JavaInteropInfo = provider( doc = "Information needed for interop with Java rules.", diff --git a/haskell/protobuf.bzl b/haskell/protobuf.bzl index fd6979793..332c312cb 100644 --- a/haskell/protobuf.bzl +++ b/haskell/protobuf.bzl @@ -1,6 +1,8 @@ """Support for protocol buffers""" load("@bazel_skylib//lib:paths.bzl", "paths") +load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") +load("@rules_cc//cc:defs.bzl", "CcInfo") load("@rules_cc//cc:find_cc_toolchain.bzl", "use_cc_toolchain") load( ":private/cc_libraries.bzl", @@ -21,10 +23,13 @@ load( ) def _capitalize_first_letter(c): - """Capitalize the first letter of the input. Unlike the built-in - `capitalize()` method, doesn't lower-case the other characters. This helps - mimic the behavior of `proto-lens-protoc`, which turns `Foo/Bar/BAZ.proto` - into `Foo/Bar/BAZ.hs` (rather than `Foo/Bar/Baz.hs`). + """ + Capitalize the first letter of the input. + + Unlike the built-in `capitalize()` method, doesn't lower-case the other + characters. This helps mimic the behavior of `proto-lens-protoc`, which + turns `Foo/Bar/BAZ.proto` into `Foo/Bar/BAZ.hs` (rather than + `Foo/Bar/Baz.hs`). Args: c: A non-empty string word. @@ -454,6 +459,7 @@ def haskell_proto_toolchain( protoc: Protoc compiler. plugin: Proto-lens-protoc plugin for protoc. deps: List of other Haskell libraries to be linked to protobuf libraries. + **kwargs: Additional arguments for _protobuf_toolchain rule. """ impl_name = name + "-impl" diff --git a/haskell/repl.bzl b/haskell/repl.bzl index 813472235..3933b7310 100644 --- a/haskell/repl.bzl +++ b/haskell/repl.bzl @@ -3,7 +3,9 @@ load("@bazel_skylib//lib:new_sets.bzl", "sets") load("@bazel_skylib//lib:paths.bzl", "paths") load("@bazel_skylib//lib:shell.bzl", "shell") +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain") +load("@rules_cc//cc/common:cc_shared_library_info.bzl", "CcSharedLibraryInfo") load("@rules_shell//shell:sh_binary.bzl", "sh_binary") load(":cc.bzl", "ghc_cc_program_args") load( diff --git a/haskell/repositories.bzl b/haskell/repositories.bzl index bda3812e8..55c0858c0 100644 --- a/haskell/repositories.bzl +++ b/haskell/repositories.bzl @@ -57,12 +57,29 @@ def rules_haskell_dependencies(): sha256 = "3b5b49006181f5f8ff626ef8ddceaa95e9bb8ad294f7b5d7b11ea9f7ddaf8c59", ) + maybe( + http_archive, + name = "bazel_features", + sha256 = "bdc12fcbe6076180d835c9dd5b3685d509966191760a0eb10b276025fcb76158", + strip_prefix = "bazel_features-1.17.0", + url = "https://github.com/bazel-contrib/bazel_features/releases/download/v1.17.0/bazel_features-v1.17.0.tar.gz", + ) + maybe( http_archive, name = "rules_cc", - urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.9/rules_cc-0.0.9.tar.gz"], - sha256 = "2037875b9a4456dce4a79d112a8ae885bbc4aad968e6587dca6e64f3a0900cdf", - strip_prefix = "rules_cc-0.0.9", + urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.1.1/rules_cc-0.1.1.tar.gz"], + sha256 = "712d77868b3152dd618c4d64faaddefcc5965f90f5de6e6dd1d5ddcd0be82d42", + strip_prefix = "rules_cc-0.1.1", + ) + + maybe( + http_archive, + name = "rules_java", + sha256 = "29ba147c583aaf5d211686029842c5278e12aaea86f66bd4a9eb5e525b7f2701", + urls = [ + "https://github.com/bazelbuild/rules_java/releases/download/6.3.0/rules_java-6.3.0.tar.gz", + ], ) maybe( diff --git a/haskell/toolchain.bzl b/haskell/toolchain.bzl index 5e033af84..562866b7c 100644 --- a/haskell/toolchain.bzl +++ b/haskell/toolchain.bzl @@ -1,6 +1,7 @@ """Rules for defining toolchains""" load("@bazel_skylib//lib:paths.bzl", "paths") +load("@rules_cc//cc:defs.bzl", "CcInfo", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain") load( "//haskell/asterius:asterius_config.bzl", @@ -350,9 +351,13 @@ def _haskell_toolchain_impl(ctx): ghc_tools = _GHC_BINARIES # GHC > 9.10 does not install ghci with relocatable = true, add the tool if it is available - if any([file.basename.startswith("ghci") for file in ctx.files.tools]): - ghc_tools = ghc_tools + ["ghci"] - else: + found = False + for file in ctx.files.tools: + if file.basename.startswith("ghci"): + ghc_tools = ghc_tools + ["ghci"] + found = True + break + if not found: # buildifier: disable=print print( "WARN: ghci binary is not available for {}, `tools.ghci` will not exist on its haskell toolchain".format( diff --git a/registry/modules/rules_nixpkgs_go/0.13.0/MODULE.bazel b/registry/modules/rules_nixpkgs_go/0.13.0/MODULE.bazel index ca991fb74..2b0eacb91 100644 --- a/registry/modules/rules_nixpkgs_go/0.13.0/MODULE.bazel +++ b/registry/modules/rules_nixpkgs_go/0.13.0/MODULE.bazel @@ -4,6 +4,6 @@ module( ) bazel_dep(name = "rules_nixpkgs_core", version = "0.13.0") -bazel_dep(name = "rules_go", repo_name = "io_bazel_rules_go", version = "0.39.1") +bazel_dep(name = "rules_go", version = "0.39.1", repo_name = "io_bazel_rules_go") bazel_dep(name = "bazel_skylib", version = "1.0.3") bazel_dep(name = "platforms", version = "0.0.4") diff --git a/registry/modules/rules_nixpkgs_java/0.13.0/MODULE.bazel b/registry/modules/rules_nixpkgs_java/0.13.0/MODULE.bazel index e68b67aba..75aa001ea 100644 --- a/registry/modules/rules_nixpkgs_java/0.13.0/MODULE.bazel +++ b/registry/modules/rules_nixpkgs_java/0.13.0/MODULE.bazel @@ -5,9 +5,10 @@ module( bazel_dep(name = "rules_nixpkgs_core", version = "0.13.0") local_path_override( - module_name = "rules_nixpkgs_core", - path = "../../core", + module_name = "rules_nixpkgs_core", + path = "../../core", ) + bazel_dep(name = "rules_java", version = "7.3.1") bazel_dep(name = "bazel_skylib", version = "1.0.3") diff --git a/rules_haskell_nix/private/declare_toolchains.bzl b/rules_haskell_nix/private/declare_toolchains.bzl index f162684ed..141dc9762 100644 --- a/rules_haskell_nix/private/declare_toolchains.bzl +++ b/rules_haskell_nix/private/declare_toolchains.bzl @@ -10,7 +10,6 @@ They are however visible from the `nix_haskell_toolchains_configurations` reposi - `toolchains` contains the configuration of these toolchains. """ -load("@rules_haskell//haskell:private/get_cpu_value.bzl", "get_cpu_value") load( "@nix_haskell_toolchains_configurations//:nix_haskell_toolchains_configurations.bzl", "ghc_labels", @@ -18,6 +17,7 @@ load( "toolchains", ) load("@rules_haskell//extensions:haskell_toolchains.bzl", "all_toolchains") +load("@rules_haskell//haskell:private/get_cpu_value.bzl", "get_cpu_value") load( "@rules_haskell_nix//:nixpkgs.bzl", "HASKELL_TOOLCHAIN_REPO_NAME_SUFFIX", diff --git a/rules_haskell_tests/MODULE.bazel b/rules_haskell_tests/MODULE.bazel index 5eb84a140..1071d500a 100644 --- a/rules_haskell_tests/MODULE.bazel +++ b/rules_haskell_tests/MODULE.bazel @@ -49,7 +49,7 @@ bazel_dep( ) bazel_dep( name = "rules_cc", - version = "0.0.9", + version = "0.1.1", ) bazel_dep( name = "rules_sh", @@ -86,20 +86,23 @@ bazel_dep( ) single_version_override( module_name = "protobuf", + patch_strip = 1, # see https://github.com/protocolbuffers/protobuf/issues/16844 # TODO: remove for protobuf version >= 31.0 patches = ["//:patches/com_google_protobuf-protoc-dbghlp.diff"], - patch_strip = 1, ) + bazel_dep( name = "zlib", version = "1.3.1.bcr.7", ) + bazel_dep( name = "rules_bazel_integration_test", version = "0.27.0", dev_dependency = True, ) + bazel_dep(name = "cgrindel_bazel_starlib", version = "0.21.0") bazel_dep(name = "rules_shell", version = "0.8.0") @@ -117,8 +120,8 @@ use_repo( "haskell_package_repository_dummy", "library_repo", "os_info", - "zlib.hs", "runfiles_repo", + "zlib.hs", ) non_modules_deps_1 = use_extension("//:non_module_deps_1.bzl", "non_module_deps_1") @@ -354,6 +357,7 @@ use_repo( "stackage-exe", "stackage-unpinned", ) + stack_snapshot.snapshot(local_snapshot = "//:stackage_snapshot.yaml") stack_snapshot.package( name = "ghc-paths", diff --git a/rules_haskell_tests/WORKSPACE b/rules_haskell_tests/WORKSPACE index 71b2eec3b..60e3ed3ae 100644 --- a/rules_haskell_tests/WORKSPACE +++ b/rules_haskell_tests/WORKSPACE @@ -34,6 +34,7 @@ http_archive( ) load("@aspect_bazel_lib//lib:repositories.bzl", "register_coreutils_toolchains") + register_coreutils_toolchains() # bazel dependencies @@ -61,6 +62,12 @@ load("@rules_proto//proto:toolchains.bzl", "rules_proto_toolchains") rules_proto_toolchains() +load("@rules_java//java:repositories.bzl", "rules_java_dependencies", "rules_java_toolchains") + +rules_java_dependencies() + +rules_java_toolchains() + # For buildifier http_archive( name = "io_bazel_rules_go", @@ -96,7 +103,6 @@ load("@rules_bazel_integration_test//bazel_integration_test:deps.bzl", "bazel_in bazel_integration_test_rules_dependencies() - load( "@rules_haskell//:constants.bzl", _default_ghc_version = "test_ghc_version", diff --git a/rules_haskell_tests/tests/analysis_tests.bzl b/rules_haskell_tests/tests/analysis_tests.bzl index 4dce7545a..22ad87f13 100644 --- a/rules_haskell_tests/tests/analysis_tests.bzl +++ b/rules_haskell_tests/tests/analysis_tests.bzl @@ -1,5 +1,6 @@ load("@bazel_skylib//lib:sets.bzl", "sets") load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts") +load("@rules_cc//cc:defs.bzl", "CcInfo") def _dynamic_libraries_in_runfiles_test_impl(ctx): env = analysistest.begin(ctx) diff --git a/rules_haskell_tests/tests/binary-linkstatic-flag/BUILD.bazel b/rules_haskell_tests/tests/binary-linkstatic-flag/BUILD.bazel index 1c4d4d1a0..352775b69 100644 --- a/rules_haskell_tests/tests/binary-linkstatic-flag/BUILD.bazel +++ b/rules_haskell_tests/tests/binary-linkstatic-flag/BUILD.bazel @@ -123,7 +123,9 @@ sh_inline_test( exit 1 fi """, - tags = ["dont_test_on_windows"], + # this test depends on cc_library targets producing a shared library + # which is no longer the case with newer rules_cc versions on macOS + tags = ["dont_test_on_windows", "dont_test_on_darwin"], ) test_suite( diff --git a/rules_haskell_tests/tests/data/BUILD.bazel b/rules_haskell_tests/tests/data/BUILD.bazel index f0996aaf6..1501f1f2c 100644 --- a/rules_haskell_tests/tests/data/BUILD.bazel +++ b/rules_haskell_tests/tests/data/BUILD.bazel @@ -9,6 +9,12 @@ cc_library( visibility = ["//visibility:public"], ) +cc_shared_library( + name = "ourclibrary-shared", + deps = ["ourclibrary"], + visibility = ["//visibility:public"], +) + cc_library( name = "ourclibrary-static", srcs = [":ourclibrary.c"], diff --git a/rules_haskell_tests/tests/haskell_cabal_empty_library/BUILD.bazel b/rules_haskell_tests/tests/haskell_cabal_empty_library/BUILD.bazel index 35619ea16..20275cbb4 100644 --- a/rules_haskell_tests/tests/haskell_cabal_empty_library/BUILD.bazel +++ b/rules_haskell_tests/tests/haskell_cabal_empty_library/BUILD.bazel @@ -1,4 +1,5 @@ -load("@rules_haskell//haskell:cabal.bzl", +load( + "@rules_haskell//haskell:cabal.bzl", "haskell_cabal_args", "haskell_cabal_library", ) @@ -42,10 +43,6 @@ haskell_cabal_library( srcs = [ "second-lib.cabal", ], - deps = [ - ":base", - ":first-lib", - ], cabal_args = "second-lib-cabal-args", tags = [ # Windows builds are not sandboxed, so both cabal files are visible to @@ -56,6 +53,10 @@ haskell_cabal_library( "dont_test_on_windows", ], version = "0.1.0.0", + deps = [ + ":base", + ":first-lib", + ], ) haskell_test( diff --git a/rules_haskell_tests/tests/haskell_cabal_reproducibility/clib/BUILD.bazel b/rules_haskell_tests/tests/haskell_cabal_reproducibility/clib/BUILD.bazel index 7ee9b7aa4..b6972d922 100644 --- a/rules_haskell_tests/tests/haskell_cabal_reproducibility/clib/BUILD.bazel +++ b/rules_haskell_tests/tests/haskell_cabal_reproducibility/clib/BUILD.bazel @@ -1,3 +1,5 @@ +load("@rules_cc//cc:cc_library.bzl", "cc_library") + cc_library( name = "myclib", srcs = ["add.c"], diff --git a/rules_haskell_tests/tests/haskell_module/repl/haskell_module_repl_test/WORKSPACE b/rules_haskell_tests/tests/haskell_module/repl/haskell_module_repl_test/WORKSPACE index 29c90eb3e..5fda6b280 100644 --- a/rules_haskell_tests/tests/haskell_module/repl/haskell_module_repl_test/WORKSPACE +++ b/rules_haskell_tests/tests/haskell_module/repl/haskell_module_repl_test/WORKSPACE @@ -14,7 +14,6 @@ rules_haskell_dependencies() load("@rules_haskell//haskell:nixpkgs.bzl", "haskell_register_ghc_nixpkgs") - GHC_VERSION = "9.4.8" haskell_register_ghc_nixpkgs( diff --git a/rules_haskell_tests/tests/haskell_proto_simple/BUILD.bazel b/rules_haskell_tests/tests/haskell_proto_simple/BUILD.bazel index a7ffe7b49..87395e5e9 100644 --- a/rules_haskell_tests/tests/haskell_proto_simple/BUILD.bazel +++ b/rules_haskell_tests/tests/haskell_proto_simple/BUILD.bazel @@ -2,6 +2,7 @@ Minimal reproduction of https://github.com/tweag/rules_haskell/issues/1111 """ +load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") load("@rules_haskell//haskell:defs.bzl", "haskell_library") load( "@rules_haskell//haskell:protobuf.bzl", diff --git a/rules_haskell_tests/tests/repl-targets/hs_lib_repl_test/BUILD.bazel b/rules_haskell_tests/tests/repl-targets/hs_lib_repl_test/BUILD.bazel index 2727ff5a3..2cdb40c1b 100644 --- a/rules_haskell_tests/tests/repl-targets/hs_lib_repl_test/BUILD.bazel +++ b/rules_haskell_tests/tests/repl-targets/hs_lib_repl_test/BUILD.bazel @@ -1,3 +1,5 @@ +load("@rules_cc//cc:cc_library.bzl", "cc_library") +load("@rules_cc//cc:cc_shared_library.bzl", "cc_shared_library") load("@rules_haskell//haskell:c2hs.bzl", "c2hs_library", "c2hs_toolchain") load( "@rules_haskell//haskell:defs.bzl", diff --git a/rules_haskell_tests/tests/solib_dir/solib_test.bzl b/rules_haskell_tests/tests/solib_dir/solib_test.bzl index bc3b0f1b5..020e389a6 100644 --- a/rules_haskell_tests/tests/solib_dir/solib_test.bzl +++ b/rules_haskell_tests/tests/solib_dir/solib_test.bzl @@ -1,3 +1,4 @@ +load("@rules_cc//cc:defs.bzl", "cc_common") load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain") _test_script_template = """#!/usr/bin/env bash diff --git a/rules_haskell_tests/tests/stackage_zlib_runpath/dynamic_libraries.bzl b/rules_haskell_tests/tests/stackage_zlib_runpath/dynamic_libraries.bzl index 4a3052a9e..769d9d865 100644 --- a/rules_haskell_tests/tests/stackage_zlib_runpath/dynamic_libraries.bzl +++ b/rules_haskell_tests/tests/stackage_zlib_runpath/dynamic_libraries.bzl @@ -1,3 +1,5 @@ +load("@rules_cc//cc:defs.bzl", "CcInfo") + def _dynamic_libraries_impl(ctx): outputs = [] solib_names = [] diff --git a/rules_haskell_tests/tests/template-haskell-with-cbits/BUILD.bazel b/rules_haskell_tests/tests/template-haskell-with-cbits/BUILD.bazel index c7a712487..2c2727f9c 100644 --- a/rules_haskell_tests/tests/template-haskell-with-cbits/BUILD.bazel +++ b/rules_haskell_tests/tests/template-haskell-with-cbits/BUILD.bazel @@ -11,8 +11,10 @@ haskell_test( "Main.hs", "TH.hs", ], - deps = [ - "//tests/data:ourclibrary", + deps = select({ + "@platforms//os:macos": ["//tests/data:ourclibrary-shared"], + "//conditions:default": ["//tests/data:ourclibrary"], + }) + [ "//tests/hackage:base", "//tests/hackage:template-haskell", ], diff --git a/start b/start index 338807470..faf25c704 100755 --- a/start +++ b/start @@ -397,7 +397,7 @@ if $BZLMOD; then module(name = "your_project_name_here", version = "0.1") bazel_dep(name = "rules_haskell", version = "0.0") -bazel_dep(name = "rules_cc", version = "0.0.9") +bazel_dep(name = "rules_cc", version = "0.1.1") haskell_toolchains = use_extension( "@rules_haskell//extensions:haskell_toolchains.bzl", diff --git a/tools/repositories.bzl b/tools/repositories.bzl index 8b0e8a773..8eab43d18 100644 --- a/tools/repositories.bzl +++ b/tools/repositories.bzl @@ -6,8 +6,10 @@ load("@rules_haskell_ghc_version//:ghc_version.bzl", "GHC_VERSION") def rules_haskell_worker_dependencies(**stack_kwargs): """ - Provide all repositories that are necessary for `rules_haskell`'s tools to - function. + Provide all repositories that are necessary for `rules_haskell`'s tools to function. + + Args: + **stack_kwargs: Additional arguments for stack_snapshot rule. """ excludes = native.existing_rules().keys()