config: more compiled languages honour //config:warnings_as_errors (part of #10075)

d/rules/defs.bzl

@@ -106,13 +106,15 @@ def _cover(kwargs):
         "//conditions:default": [],
     }))
 
+_WARNINGS = ("dopts", ["-w"], [])
+
 def d_library(name, srcs, visibility = None, **kwargs):
     """Thin wrapper over the rules_d d_library rule."""
     kwargs = d_kwargs(kwargs)
     kwargs = _cover(kwargs)
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _string_srcs(name, kwargs)
-    dx_wrap(name, _d_library, _d_library_forward, srcs, visibility = visibility, quality_srcs = quality_srcs, **kwargs)
+    dx_wrap(name, _d_library, _d_library_forward, srcs, visibility = visibility, quality_srcs = quality_srcs, warnings = _WARNINGS, **kwargs)
 
 def d_binary(name, *, srcs = None, visibility = None, **kwargs):
     """Thin wrapper over the rules_d d_binary rule. srcs is required."""
@@ -122,7 +124,7 @@ def d_binary(name, *, srcs = None, visibility = None, **kwargs):
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _string_srcs(name, kwargs)
     upstream = dict(kwargs, tags = dx_upstream_tags(kwargs.get("tags", None)))
-    dx_wrap_binary(name, _d_binary, _d_binary_forward, srcs, visibility = visibility, upstream_kwargs = upstream, quality_srcs = quality_srcs, **kwargs)
+    dx_wrap_binary(name, _d_binary, _d_binary_forward, srcs, visibility = visibility, upstream_kwargs = upstream, quality_srcs = quality_srcs, warnings = _WARNINGS, **kwargs)
 
 D_COVERAGE_COLLECTOR = True
 
@@ -133,7 +135,7 @@ def d_test(name, *, srcs = None, visibility = None, **kwargs):
     kwargs = d_kwargs(kwargs)
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _cover(_string_srcs(name, kwargs))
-    dx_wrap_test(name, _d_test, _d_forward_test, srcs, visibility = visibility, quality_srcs = quality_srcs, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, coverage_collector = D_COVERAGE_COLLECTOR, **kwargs)
+    dx_wrap_test(name, _d_test, _d_forward_test, srcs, visibility = visibility, quality_srcs = quality_srcs, warnings = _WARNINGS, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, coverage_collector = D_COVERAGE_COLLECTOR, **kwargs)
 
 def d_fuzz_test(name, *, srcs = None, visibility = None, tags = None, dopts = None, linkopts = None, **kwargs):
     """A libFuzzer binary with AddressSanitizer plus a `<name>_run` runner for `dx fuzz`. srcs define LLVMFuzzerTestOneInput, for example with ldc.libfuzzer."""

erlang/rules/defs.bzl

@@ -16,7 +16,7 @@ load("//erlang/toolchain:cells.bzl", "otp_compatible_with")
 load("//erlang/toolchain:pins.bzl", "OTP_DIALYZER_UNPORTED_CELLS", "OTP_NIF_UNPORTED_CELLS")
 load("//libs/launcher:defs.bzl", "NATIVE_LAUNCHER_ATTRS", "target_is_windows", "write_native_launcher")
 load("//libs/starlark:fuzz_bench.bzl", "merge_tags", "with_default_size")
-load("//libs/starlark:wrapper.bzl", "DX_EXEC_PROVIDES", "dx_binary_forward_kwargs", "dx_binary_upstream_kwargs", "dx_executable_forward_rule", "dx_forward_data_attr", "dx_language_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_setdefaults", "dx_test_forward_kwargs", "dx_test_upstream_kwargs", "dx_upstream_tags", "dx_wrap", "dx_wrap_test")
+load("//libs/starlark:wrapper.bzl", "DX_EXEC_PROVIDES", "dx_binary_forward_kwargs", "dx_binary_upstream_kwargs", "dx_executable_forward_rule", "dx_forward_data_attr", "dx_language_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_setdefaults", "dx_test_forward_kwargs", "dx_test_upstream_kwargs", "dx_upstream_tags", "dx_warnings_as_errors", "dx_wrap", "dx_wrap_test")
 load("//quality:sources.bzl", "QualitySourcesInfo")
 load(":kwargs.bzl", "erlang_app_forward_kwargs", "erlang_kwargs", _ERLANG_CELLS = "ERLANG_CELLS", _ERLANG_COMPATIBLE_WITH = "ERLANG_COMPATIBLE_WITH")
 
@@ -286,8 +286,15 @@ def app_sources(kwargs, glob = None):
     excluded = [entry for entry in _listed(kwargs, ["extra_srcs", "extra_hdrs"]) if not _is_label(entry)]
     return glob(ERLANG_SOURCE_GLOBS, exclude = excluded, allow_empty = True)
 
+_ERLC_OPTS = ["+debug_info", "+warn_export_vars", "+warn_shadow_vars", "+warn_obsolete_guard"] + select({
+    Label("@rules_erlang//:debug_build"): [],
+    "//conditions:default": ["+deterministic"],
+})
+
 def _app(upstream_macro, name, testonly, visibility, kwargs):
-    kwargs = erlang_kwargs(kwargs)
+    kwargs, warning_flags = dx_warnings_as_errors(erlang_kwargs(kwargs), ["-Werror"])
+    if "erlc_opts" not in kwargs and "beam_files" not in kwargs:
+        kwargs["erlc_opts"] = _ERLC_OPTS + warning_flags
     tags = kwargs.pop("tags", None)
     nifs = kwargs.pop("nifs", [])
     if nifs:

families/dotnet/BUILD.bazel

@@ -1,3 +1,4 @@
+load("@rules_dx//libs/starlark:conformance.bzl", "dx_warnings_parity_test")
 load("@rules_dx//quality:fixtures.bzl", "real_source_target")
 load("@rules_shell//shell:sh_test.bzl", "sh_test")
 
@@ -52,3 +53,12 @@ exports_files(
     visibility = ["//.dx:__pkg__"],
 )
 # dx:end exports
+
+dx_warnings_parity_test(
+    name = "warnings_parity_test",
+    mapped = {
+        "csharp": ["//csharp/rules:kwargs.bzl"],
+        "fsharp": ["//fsharp/rules:kwargs.bzl"],
+    },
+    opted_out = [],
+)

fortran/rules/defs.bzl

@@ -82,6 +82,8 @@ _fortran_forward_test = dx_executable_forward_rule(
     coverage_providers = _fortran_test_coverage,
 )
 
+_WARNINGS = ("copts", ["-Werror"], [])
+
 def library_name(name):
     """Returns the name of the private Fortran library behind one executable."""
     return name + "_fortran"
@@ -100,12 +102,12 @@ _fortran_cc_test = _linked(_cc_test)
 
 def fortran_library(name, srcs = None, visibility = None, **kwargs):
     """Thin wrapper over the rules_fortran fortran_library rule."""
-    dx_wrap(name, _fortran_library, _library_forward, srcs or [], visibility = visibility, **fortran_with_defaults(kwargs))
+    dx_wrap(name, _fortran_library, _library_forward, srcs or [], visibility = visibility, warnings = _WARNINGS, **fortran_with_defaults(kwargs))
 
 def fortran_binary(name, srcs = None, visibility = None, **kwargs):
     """Compiles Fortran sources with rules_fortran and links them with cc_binary."""
-    dx_wrap_binary(name, _fortran_cc_binary, _binary_forward, srcs or [], visibility = visibility, **fortran_with_defaults(kwargs))
+    dx_wrap_binary(name, _fortran_cc_binary, _binary_forward, srcs or [], visibility = visibility, warnings = _WARNINGS, **fortran_with_defaults(kwargs))
 
 def fortran_test(name, srcs = None, visibility = None, **kwargs):
     """Compiles Fortran sources with rules_fortran and links them with cc_test."""
-    dx_wrap_test(name, _fortran_cc_test, _fortran_forward_test, srcs or [], visibility = visibility, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, **fortran_with_defaults(kwargs))
+    dx_wrap_test(name, _fortran_cc_test, _fortran_forward_test, srcs or [], visibility = visibility, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, warnings = _WARNINGS, **fortran_with_defaults(kwargs))

go/rules/defs.bzl

@@ -74,20 +74,25 @@ _go_forward_test = dx_executable_forward_rule(
     optional_providers = [_GoArchive],
 )
 
+_WARNINGS = ("copts", ["-Werror"], [])
+
+def _cgo_warnings(kwargs):
+    return _WARNINGS if kwargs.get("cgo") == True else None
+
 def _cgo_kwargs(kwargs):
     return {"cgo": kwargs.get("cgo", False)}
 
 def go_library(name, srcs, importpath, visibility = None, **kwargs):
     """Minimal wrapper over go_library."""
-    dx_wrap(name, _go_library, _go_library_forward, srcs, visibility = visibility, importpath = importpath, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap(name, _go_library, _go_library_forward, srcs, visibility = visibility, importpath = importpath, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_binary(name, *, srcs = None, visibility = None, **kwargs):
     """Minimal wrapper over go_binary. cgo is off unless set."""
-    dx_wrap_binary(name, _go_binary, _go_binary_forward, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap_binary(name, _go_binary, _go_binary_forward, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_test(name, *, srcs = None, visibility = None, **kwargs):
     """Minimal wrapper over go_test. cgo is off unless set."""
-    dx_wrap_test(name, _go_test, _go_forward_test, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap_test(name, _go_test, _go_forward_test, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_fuzz_test(name, *, fuzz, srcs = None, visibility = None, tags = None, **kwargs):
     """A go_test plus a `<name>_run` runner that fuzzes the function `fuzz` for `dx fuzz`."""

libs/starlark/BUILD.bazel

@@ -33,6 +33,7 @@ exports_files([
     "seven_zip.bzl",
     "tag_probe.bzl",
     "wrapper.bzl",
+    "warnings_parity.sh",
     "wrapper_signatures.sh",
 ])
 

libs/starlark/conformance.bzl

@@ -269,3 +269,28 @@ def dx_wrapper_signature_test(name, defs = "defs.bzl"):
             "//conditions:default": [],
         }),
     )
+
+def dx_warnings_parity_test(name, mapped, opted_out):
+    """Fails when a compiled language neither maps warnings_as_errors nor opts out.
+
+    Args:
+      name: test name.
+      mapped: dict of language to the .bzl files that map the flag.
+      opted_out: list of languages whose compiler reports no warnings.
+    """
+    args = []
+    data = []
+    for lang in sorted(mapped.keys()):
+        args.append(lang + "=" + ",".join(["$(rootpath {})".format(f) for f in mapped[lang]]))
+        data.extend(mapped[lang])
+    args.extend([lang + "=-" for lang in sorted(opted_out)])
+    sh_test(
+        name = name,
+        srcs = [Label("//libs/starlark:warnings_parity.sh")],
+        args = args,
+        data = data,
+        target_compatible_with = select({
+            "@platforms//os:windows": ["@platforms//:incompatible"],
+            "//conditions:default": [],
+        }),
+    )

libs/starlark/tests/BUILD.bazel

@@ -1,5 +1,6 @@
 load("@bazel_skylib//rules:write_file.bzl", "write_file")
 load("//cc/rules:defs.bzl", "cc_test")
+load("//libs/starlark:conformance.bzl", "dx_warnings_parity_test")
 load("//libs/starlark:defs.bzl", "starlark_test")
 load("//libs/starlark:failure_test.bzl", "failure_test")
 load("//libs/starlark/tests/fixtures/starlark_futures:aspect_subjects.bzl", "aspect_group", "aspect_leaf")
@@ -270,3 +271,27 @@ starlark_test(
     mode = "analysis",
     subjects = [":exec_group_forwarder"],
 )
+
+dx_warnings_parity_test(
+    name = "warnings_parity_test",
+    mapped = {
+        "cc": ["//cc/rules:defs.bzl"],
+        "d": ["//d/rules:defs.bzl"],
+        "elixir": ["//elixir/rules:kwargs.bzl"],
+        "erlang": ["//erlang/rules:defs.bzl"],
+        "fortran": ["//fortran/rules:defs.bzl"],
+        "go": ["//go/rules:defs.bzl"],
+        "haskell": ["//haskell/rules:kwargs.bzl"],
+        "java": ["//java/rules:kwargs.bzl"],
+        "kotlin": ["//kotlin/rules:defs.bzl"],
+        "ocaml": ["//ocaml/rules:defs.bzl"],
+        "rust": ["//rust/rules:defs.bzl"],
+        "scala": ["//scala/rules:validate.bzl"],
+        "swift": ["//swift/rules:defs.bzl"],
+    },
+    opted_out = [
+        "dart",
+        "typescript",
+        "zig",
+    ],
+)

libs/starlark/warnings_parity.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Fails when a compiled language neither maps warnings_as_errors nor opts out.
+# Args: language=file[,file...] for a mapped language, language=- for an opt-out.
+set -euo pipefail
+
+status=0
+for entry in "$@"; do
+    lang="${entry%%=*}"
+    files="${entry#*=}"
+    if [[ "$files" == "-" ]]; then
+        continue
+    fi
+    if ! grep -qE 'dx_warnings_as_errors\(|warnings = _[a-z_]*WARNINGS|warnings = _cgo_warnings' ${files//,/ }; then
+        echo "$lang: no warnings_as_errors mapping in $files" >&2
+        status=1
+    fi
+done
+exit "$status"

libs/starlark/wrapper.bzl

@@ -640,6 +640,7 @@ def dx_test_upstream_kwargs(kwargs, srcs = None, upstream_visibility = None):
     out.setdefault("size", "small")
     out.pop("env", None)
     out.pop("env_inherit", None)
+    out.pop("warnings_as_errors", None)
     if srcs != None:
         out["srcs"] = srcs
     return out
@@ -655,11 +656,12 @@ def dx_binary_upstream_kwargs(kwargs, srcs, upstream_visibility = None):
     out["visibility"] = upstream_visibility if upstream_visibility != None else ["//visibility:private"]
     out.pop("env", None)
     out.pop("env_inherit", None)
+    out.pop("warnings_as_errors", None)
     return out
 
 def dx_wrap_upstream_kwargs(kwargs, srcs = None, upstream_visibility = None):
     """Returns the private upstream kwargs for one library shape."""
-    out = {key: value for key, value in kwargs.items() if key not in ("tags", "srcs")}
+    out = {key: value for key, value in kwargs.items() if key not in ("tags", "srcs", "warnings_as_errors")}
     if srcs != None:
         out["srcs"] = srcs
     out["tags"] = dx_upstream_tags(kwargs.get("tags", None))
@@ -679,9 +681,17 @@ def dx_test_forward_kwargs(kwargs):
         out["target_compatible_with"] = kwargs["target_compatible_with"]
     return out
 
-def dx_wrap_binary(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, **kwargs):
+def dx_warnings_upstream(upstream, kwargs, warnings):
+    """Returns upstream with the warnings_as_errors flags appended to the attribute warnings names."""
+    if warnings == None:
+        return upstream
+    key, on, off = warnings
+    _, flag = dx_warnings_as_errors(kwargs, on, off)
+    return dx_append_flags(upstream, key, flag)
+
+def dx_wrap_binary(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream binary plus its public forwarder."""
-    effective = dx_binary_upstream_kwargs(upstream_kwargs if upstream_kwargs != None else kwargs, srcs, upstream_visibility)
+    effective = dx_binary_upstream_kwargs(dx_warnings_upstream(upstream_kwargs if upstream_kwargs != None else kwargs, kwargs, warnings), srcs, upstream_visibility)
     upstream_rule(
         name = name + "_upstream",
         **effective
@@ -710,9 +720,9 @@ def dx_with_tag(tags, tag):
         out.append(tag)
     return out
 
-def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, coverage_collector = True, upstream_visibility = None, **kwargs):
+def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, coverage_collector = True, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream test plus its public forwarder."""
-    base = dict(upstream_kwargs) if upstream_kwargs != None else dict(kwargs)
+    base = dx_warnings_upstream(dict(upstream_kwargs) if upstream_kwargs != None else dict(kwargs), kwargs, warnings)
     effective = dx_test_upstream_kwargs(base, srcs = srcs, upstream_visibility = upstream_visibility)
     forward_srcs = quality_srcs if quality_srcs != None else (srcs if srcs != None else [])
     forward_kwargs = dx_test_forward_kwargs(kwargs)
@@ -733,11 +743,11 @@ def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, ups
         **forward_kwargs
     )
 
-def dx_wrap(name, upstream_rule, forward_rule, srcs = None, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, **kwargs):
+def dx_wrap(name, upstream_rule, forward_rule, srcs = None, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream library target plus its public forwarder."""
     upstream_rule(
         name = name + "_upstream",
-        **dx_wrap_upstream_kwargs(upstream_kwargs if upstream_kwargs != None else kwargs, srcs, upstream_visibility)
+        **dx_wrap_upstream_kwargs(dx_warnings_upstream(upstream_kwargs if upstream_kwargs != None else kwargs, kwargs, warnings), srcs, upstream_visibility)
     )
     forward_kwargs = dx_wrap_forward_kwargs(kwargs)
     if extra_forward_kwargs: