Lightweight coding agent that runs in your terminal
Rust
Add explicit toolchain inputs for native voice builds (#43109)
Benjamin Carlssone67a8ae6c997
diff --git a/.bazelrc b/.bazelrcindex b9473c0a16..2ae73f52b7 100644--- a/.bazelrc+++ b/.bazelrc@@ -27,6 +27,8 @@ common --incompatible_strict_action_env# Not ideal, but We need to allow dotslash to be foundcommon:linux --test_env=PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbincommon:macos --test_env=PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin+# Native pkg-config configure checks execute target programs.+common:macos --strategy=CcConfigureMakeRule=remote,sandboxed,local# Pass through some env vars Windows needs to use powershell?common:windows --test_env=SYSTEMROOTdiff --git a/MODULE.bazel b/MODULE.bazelindex 0018fb347f..7c3b278833 100644--- a/MODULE.bazel+++ b/MODULE.bazel@@ -147,6 +147,22 @@ bazel_dep(name = "rules_platform", version = "0.1.0")bazel_dep(name = "aws-lc", version = "5.1.0.bcr.1")bazel_dep(name = "rules_rs", version = "0.0.96")bazel_dep(name = "rules_foreign_cc", version = "0.15.1")+single_version_override(+ module_name = "rules_foreign_cc",+ patch_strip = 1,+ patches = [+ "//patches:rules_foreign_cc_make_cppflags.patch",+ "//patches:rules_foreign_cc_make_xcompile.patch",+ ],+ version = "0.15.1",+)++# Use the existing pinned Make build for foreign_cc consumers, including the+# native voice pkg-config bootstrap, instead of a PATH-provided Make.+register_toolchains("@rules_foreign_cc//toolchains:built_make_toolchain")++foreign_cc_tools = use_extension("@rules_foreign_cc//foreign_cc:extensions.bzl", "tools")+use_repo(foreign_cc_tools, "pkgconfig_src")single_version_override(module_name = "rules_rs",diff --git a/MODULE.bazel.lock b/MODULE.bazel.lockindex 8a91f2cbee..01a8eea312 100644--- a/MODULE.bazel.lock+++ b/MODULE.bazel.lock@@ -60,7 +60,6 @@"https://bcr.bazel.build/modules/bazel_lib/3.2.2/MODULE.bazel": "e2c890c8a515d6bca9c66d47718aa9e44b458fde64ec7204b8030bf2d349058c","https://bcr.bazel.build/modules/bazel_lib/3.2.2/source.json": "9e84e115c20e14652c5c21401ae85ff4daa8702e265b5c0b3bf89353f17aa212","https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8",- "https://bcr.bazel.build/modules/bazel_skylib/1.1.1/MODULE.bazel": "1add3e7d93ff2e6998f9e118022c84d163917d912f5afafb3058e3d2f1545b5e","https://bcr.bazel.build/modules/bazel_skylib/1.2.0/MODULE.bazel": "44fe84260e454ed94ad326352a698422dbe372b21a1ac9f3eab76eb531223686","https://bcr.bazel.build/modules/bazel_skylib/1.2.1/MODULE.bazel": "f35baf9da0efe45fa3da1696ae906eea3d615ad41e2e3def4aeb4e8bc0ef9a7a","https://bcr.bazel.build/modules/bazel_skylib/1.3.0/MODULE.bazel": "20228b92868bf5cfc41bda7afc8a8ba2a543201851de39d990ec957b513579c5",@@ -171,7 +170,6 @@"https://bcr.bazel.build/modules/rules_cc/0.2.8/MODULE.bazel": "f1df20f0bf22c28192a794f29b501ee2018fa37a3862a1a2132ae2940a23a642","https://bcr.bazel.build/modules/rules_foreign_cc/0.15.1/MODULE.bazel": "c2c60d26c79fda484acb95cdbec46e89d6b28b4845cb277160ce1e0c8622bb88","https://bcr.bazel.build/modules/rules_foreign_cc/0.15.1/source.json": "a161811a63ba8a859086da3b7ff3ad04f2e9c255d7727b41087103fc0eb22f55",- "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6","https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/MODULE.bazel": "40c97d1144356f52905566c55811f13b299453a14ac7769dfba2ac38192337a8","https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74","https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86",diff --git a/patches/BUILD.bazel b/patches/BUILD.bazelindex b5b4bc899f..18442dc5dd 100644--- a/patches/BUILD.bazel+++ b/patches/BUILD.bazel@@ -8,6 +8,8 @@ exports_files(["rules_rust_windows_msvc_direct_link_args.patch","rules_rust_windows_process_wrapper_skip_temp_outputs.patch","rules_cc_rusty_v8_custom_libcxx.patch",+ "rules_foreign_cc_make_cppflags.patch",+ "rules_foreign_cc_make_xcompile.patch","rules_rs_build_script_deps_annotation.patch","rules_rs_windows_msvc_linker.patch","rules_rs_zlib_snapshot_urls.patch",diff --git a/patches/rules_foreign_cc_make_cppflags.patch b/patches/rules_foreign_cc_make_cppflags.patchnew file mode 100644index 0000000000..96cf53df90--- /dev/null+++ b/patches/rules_foreign_cc_make_cppflags.patch@@ -0,0 +1,15 @@+diff --git a/foreign_cc/built_tools/make_build.bzl b/foreign_cc/built_tools/make_build.bzl+--- a/foreign_cc/built_tools/make_build.bzl++++ b/foreign_cc/built_tools/make_build.bzl+@@ -114,6 +114,11 @@+ "ARFLAGS": _join_flags_list(ctx.workspace_name, arflags),+ "CC": absolute_cc,+ "CFLAGS": _join_flags_list(ctx.workspace_name, non_sysroot_cflags),++ # Configure's preprocessor checks need the declared header paths too.++ "CPPFLAGS": " ".join([++ "$${CPPFLAGS:-}$$",++ _join_flags_list(ctx.workspace_name, non_sysroot_cflags),++ ]).strip(),+ "LD": absolute_ld,+ "LDFLAGS": _join_flags_list(ctx.workspace_name, non_sysroot_ldflags),+ })diff --git a/patches/rules_foreign_cc_make_xcompile.patch b/patches/rules_foreign_cc_make_xcompile.patchnew file mode 100644index 0000000000..097e87bc18--- /dev/null+++ b/patches/rules_foreign_cc_make_xcompile.patch@@ -0,0 +1,10 @@+diff --git a/toolchains/private/BUILD.bazel b/toolchains/private/BUILD.bazel+--- a/toolchains/private/BUILD.bazel++++ b/toolchains/private/BUILD.bazel+@@ -23,5 +23,6 @@+ make_tool(+ name = "make_tool",+ srcs = "@gnumake_src//:all_srcs",++ configure_xcompile = True,+ tags = ["manual"],+ )diff --git a/third_party/voice/BUILD.bazel b/third_party/voice/BUILD.bazelindex 85feb73574..e98c672033 100644--- a/third_party/voice/BUILD.bazel+++ b/third_party/voice/BUILD.bazel@@ -1,3 +1,6 @@+load("@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl", "native_tool_toolchain")+load(":pkg_config.bzl", "pkg_config")+# All native build consumers must receive the same pinned source manifest.exports_files(["opus-toolchain.cmake"])@@ -45,3 +48,58 @@ filegroup(],visibility = ["//visibility:public"],)++alias(+ name = "pkg_config_linker",+ actual = select({+ "@platforms//os:macos": "@llvm//tools:ld64.lld",+ "//conditions:default": "@llvm//tools:ld.lld",+ }),+)++# Keep the pinned pkg-config sources, but explicitly use LLVM archive tools.+# The upstream bootstrap otherwise selects host ar/ranlib on macOS.+pkg_config(+ name = "pkg_config",+ build_data = [+ ":pkg_config_linker",+ "@llvm//tools:llvm-ar",+ "@llvm//tools:llvm-ranlib",+ ],+ # foreign_cc normalizes copied source timestamps, preserving the release+ # configure files when remote execution materializes inputs in a new order.+ configure_in_place = True,+ configure_options = [+ "--with-internal-glib",+ "--disable-shared",+ ],+ copts = ["-Wno-int-conversion"],+ env = {+ "AR": "$(execpath @llvm//tools:llvm-ar)",+ "LD": "$(execpath :pkg_config_linker)",+ "PKG_CONFIG": "/bin/false",+ "RANLIB": "$(execpath @llvm//tools:llvm-ranlib)",+ },+ lib_source = "@pkgconfig_src//:all_srcs",+ # foreign_cc rewrites *-config files as text. Keep the executable out of+ # that transformation, which otherwise corrupts its native code signature.+ out_binaries = ["pkg-config-tool"],+ out_include_dir = "",+ out_static_libs = [],+ postfix_script = 'mv "$$INSTALLDIR/bin/pkg-config" "$$INSTALLDIR/bin/pkg-config-tool"',+ tags = ["manual"],+ target_compatible_with = select({+ "@platforms//os:windows": ["@platforms//:incompatible"],+ "//conditions:default": [],+ }),+ # Internal GLib needs no pkg-config. Avoid bootstrapping another copy first;+ # the explicit failing command above forbids falling back to a host copy.+ toolchain = "@rules_foreign_cc//toolchains:preinstalled_pkgconfig_toolchain",+)++native_tool_toolchain(+ name = "pkg_config_tool",+ path = "$(execpath :pkg_config)",+ tags = ["manual"],+ target = ":pkg_config",+)diff --git a/third_party/voice/README.md b/third_party/voice/README.mdindex 0e864abb33..7bf06470ea 100644--- a/third_party/voice/README.md+++ b/third_party/voice/README.md@@ -77,7 +77,15 @@ transitive imports must satisfy the same private-library and system-import check## Native build recipe`build_native.py` runs the unmodified upstream build systems in a new output-directory, using the same archives. Specify the target and existing compiler,+directory, using the same archives. Unix builds accept repeated `--c-flag=...`,+`--cxx-flag=...`, `--link-flag=...` and optional `--ar`/`--ranlib` inputs.+These overrides are rejected on Windows; ambient flags remain ignored.+Libffi uses compiler response files to preserve literal definitions through+configure, recursive Make and libtool. Response-file paths must not require shell+quoting. Its+Autoconf recipe cannot preserve flags containing whitespace; those are rejected.+Declared archiver and ranlib paths must not require shell quoting for libffi.+Specify the target and existing compiler,CMake, make, pkg-config and shell paths explicitly. It requires a matchingnative host: GNU Linux, macOS, or Windows MSVC, on x64 or ARM64.diff --git a/third_party/voice/build_native.py b/third_party/voice/build_native.pyindex 3ae5669557..183043516d 100644--- a/third_party/voice/build_native.py+++ b/third_party/voice/build_native.py@@ -66,6 +66,25 @@ class NativeBuild:name: getattr(args, name).absolute()for name in ("cc", "cxx", "cmake", "make", "pkg_config", "shell")}+ self.toolchain.update(+ (name, path.absolute())+ for name in ("ar", "ranlib")+ if (path := getattr(args, name, None)) is not None+ )+ self.quote = subprocess.list2cmdline if self.windows else shlex.join+ self.flags = {+ variable: list(getattr(args, argument, []))+ for variable, argument in (+ ("CFLAGS", "c_flag"),+ ("CXXFLAGS", "cxx_flag"),+ ("LDFLAGS", "link_flag"),+ )+ }+ if self.windows and (+ any(self.flags.values())+ or any(name in self.toolchain for name in ("ar", "ranlib"))+ ):+ raise ValueError("Explicit toolchain overrides require a Unix build host")self.bootstrap_make = (args.bootstrap_make or args.make).absolute()for tool in (*self.toolchain.values(), self.bootstrap_make):if not tool.is_file():@@ -127,6 +146,14 @@ class NativeBuild:})self.cmake_platform = []+ self.environment.update(+ (name, self.quote(flags)) for name, flags in self.flags.items() if flags+ )+ self.environment.update(+ (name.upper(), self.quote([str(self.toolchain[name])]))+ for name in ("ar", "ranlib")+ if name in self.toolchain+ )if args.target.endswith("apple-darwin"):self.environment["MACOSX_DEPLOYMENT_TARGET"] = args.deployment_targetself.cmake_platform = [@@ -142,6 +169,7 @@ class NativeBuild:self.record = {"target": args.target,"deployment_target": args.deployment_target,+ "flags": self.flags,"steps": [],}@@ -199,6 +227,11 @@ class NativeBuild:"-DCMAKE_INSTALL_LIBDIR=lib",f"-DCMAKE_C_COMPILER={self.toolchain['cc']}",f"-DCMAKE_CXX_COMPILER={self.toolchain['cxx']}",+ *(+ f"-DCMAKE_{name.upper()}={self.toolchain[name]}"+ for name in ("ar", "ranlib")+ if name in self.toolchain+ ),f"-DCMAKE_PREFIX_PATH={self.prefix}","-DCMAKE_FIND_USE_PACKAGE_REGISTRY=OFF","-DCMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY=OFF",@@ -223,8 +256,7 @@ class NativeBuild:def meson(self, name, options):directory = self.output / "build" / namemeson = [sys.executable, self.sources["meson"] / "meson.py"]- quote = subprocess.list2cmdline if self.windows else shlex.join- include = quote([f"{'/I' if self.windows else '-I'}{self.prefix / 'include'}"])+ include = f"{'/I' if self.windows else '-I'}{self.prefix / 'include'}"link = ([f"/LIBPATH:{self.prefix / 'lib'}"]if self.windows@@ -233,8 +265,14 @@ class NativeBuild:if self.args.target.endswith("unknown-linux-gnu"):link[-1] = "-Wl,-rpath,$ORIGIN:$ORIGIN/.."self.environment.update(- {"CFLAGS": include, "CXXFLAGS": include, "LDFLAGS": quote(link)}+ {+ name: self.quote([*flags, *(link if name == "LDFLAGS" else [include])])+ for name, flags in self.flags.items()+ })+ if self.args.target.endswith("apple-darwin"):+ self.environment["OBJC"] = str(self.toolchain["cc"])+ self.environment["OBJCFLAGS"] = self.environment["CFLAGS"]self.run(name + "-configure",[@@ -340,6 +378,36 @@ class NativeBuild:"CONFIG_SHELL": self.posix_path(self.toolchain["shell"]),})+ else:+ for name in ("ar", "ranlib"):+ if name in self.toolchain:+ path = str(self.toolchain[name])+ if shlex.quote(path) != path:+ raise ValueError(+ f"libffi {name} path cannot require shell quoting"+ )+ # Response files preserve compiler arguments through Autoconf's word+ # splitting and Make/libtool's shell expansion without losing flags+ # added by configure (such as -fexceptions).+ for name, flags in self.flags.items():+ if any(+ any(character.isspace() for character in flag) for flag in flags+ ):+ raise ValueError("libffi flags cannot contain whitespace")+ if flags:+ response = ffi_build / f"{name.lower()}.rsp"+ if shlex.quote(str(response)) != str(response):+ raise ValueError(+ "libffi response-file path cannot require shell quoting"+ )+ response.write_text(+ "\n".join(+ '"' + flag.replace("\\", "\\\\").replace('"', '\\"') + '"'+ for flag in flags+ )+ + "\n"+ )+ environment[name] = f"@{response}"self.run("libffi-configure",[@@ -446,6 +514,10 @@ def main():type=Path,help="NMake on Windows; defaults to --make elsewhere",)+ for name in ("ar", "ranlib"):+ parser.add_argument(f"--{name}", type=Path)+ for name in ("c-flag", "cxx-flag", "link-flag"):+ parser.add_argument(f"--{name}", action="append", default=[])parser.add_argument("--target", required=True)parser.add_argument("--deployment-target",diff --git a/third_party/voice/pkg_config.bzl b/third_party/voice/pkg_config.bzlnew file mode 100644index 0000000000..4b87d36a3f--- /dev/null+++ b/third_party/voice/pkg_config.bzl@@ -0,0 +1,33 @@+"""Build the pinned pkg-config with native Mac configure checks."""++load("@rules_foreign_cc//foreign_cc:defs.bzl", "configure_make_variant")++def pkg_config(name, **kwargs):+ """Keep Linux remote builds and select native Mac producers by OS and CPU."""+ tags = kwargs.pop("tags", [])+ configure_make_variant(+ name = name + "_default",+ tags = tags,+ **kwargs+ )+ for arch in ["aarch64", "x86_64"]:+ native.config_setting(+ name = name + "_macos_" + arch,+ constraint_values = ["@platforms//os:macos", "@platforms//cpu:" + arch],+ )+ configure_make_variant(+ name = name + "_native_macos_" + arch,+ exec_compatible_with = ["@platforms//os:macos", "@platforms//cpu:" + arch],+ tags = tags + ["no-remote-exec"],+ **kwargs+ )+ native.alias(+ name = name,+ tags = tags,+ actual = select({+ ":" + name + "_macos_aarch64": ":" + name + "_native_macos_aarch64",+ ":" + name + "_macos_x86_64": ":" + name + "_native_macos_x86_64",+ "//conditions:default": ":" + name + "_default",+ }),+ visibility = kwargs.get("visibility"),+ )diff --git a/third_party/voice/test_build_native.py b/third_party/voice/test_build_native.pyindex 7da0ce2b56..6d7242b4e6 100644--- a/third_party/voice/test_build_native.py+++ b/third_party/voice/test_build_native.py@@ -96,16 +96,39 @@ class NativeBuildTests(unittest.TestCase):self.args.cxx = compilerself.args.cmake = Path(tools["cmake"])self.args.make = Path(tools["make"])+ headers = self.root / "declared headers"+ headers.mkdir()+ (headers / "build_flag.h").write_text(+ '#define BUILD_FLAG "linked with flags"\n'+ )+ self.args.cxx_flag = [f"-I{headers}"]+ for name in ("ar", "ranlib"):+ tool = shutil.which(name)+ if tool is None:+ self.skipTest(f"Requires {name}")+ wrapper = self.root / f"declared {name}"+ wrapper.write_text(+ "#!/bin/sh\n"+ f"touch {shlex.quote(str(self.root / (name + '.used')))}\n"+ f'exec {shlex.quote(tool)} "$@"\n'+ )+ wrapper.chmod(0o755)+ setattr(self.args, name, wrapper)source = self.root / "cpp-source"source.mkdir()(source / "CMakeLists.txt").write_text("cmake_minimum_required(VERSION 3.15)\n""project(cpp_driver LANGUAGES CXX)\n"+ "add_library(message STATIC message.cpp)\n""add_executable(cpp_driver main.cpp)\n"+ "target_link_libraries(cpp_driver PRIVATE message)\n""install(TARGETS cpp_driver DESTINATION bin)\n")(source / "main.cpp").write_text(- '#include <iostream>\nint main() { std::cout << "linked"; }\n'+ "#include <iostream>\nconst char* message();\nint main() { std::cout << message(); }\n"+ )+ (source / "message.cpp").write_text(+ '#include "build_flag.h"\nconst char* message() { return BUILD_FLAG; }\n')build = NativeBuild(self.args, self.environment)build.output.mkdir()@@ -117,7 +140,98 @@ class NativeBuildTests(unittest.TestCase):capture_output=True,text=True,)- self.assertEqual(result.stdout, "linked")+ self.assertEqual(result.stdout, "linked with flags")+ self.assertTrue(+ all((self.root / (name + ".used")).is_file() for name in ("ar", "ranlib"))+ )++ @unittest.skipIf(os.name == "nt", "Exercises Autoconf's Unix tool expansion")+ def test_libffi_rejects_quoted_archive_tool_paths(self):+ for name in ("ar", "ranlib"):+ for index, path in enumerate(("declared tool", "declared'tool")):+ with self.subTest(name=name, path=path):+ (self.root / path).touch()+ setattr(self.args, name, self.root / path)+ self.args.output = self.root / f"{name}-{index}"+ build = NativeBuild(self.args, self.environment)+ with (+ patch(+ "build_native.prepare_sources",+ side_effect=lambda *args: (build.output / "build").mkdir(),+ ),+ patch.object(build, "cmake"),+ patch.object(build, "meson"),+ patch.object(build, "run"),+ self.assertRaisesRegex(ValueError, "libffi .* path"),+ ):+ build.build()+ setattr(self.args, name, None)++ @unittest.skipIf(os.name == "nt", "Exercises Autoconf's Unix flag expansion")+ def test_libffi_compiler_receives_literal_defines_without_shell_quotes(self):+ compiler = shutil.which("cc")+ if compiler is None:+ self.skipTest("Requires a C compiler")+ self.args.cc = Path(compiler)+ make = shutil.which("make")+ if make is None:+ self.skipTest("Requires Make")+ for index, (flag, expected) in enumerate(+ [+ ('-DBUILD_FLAG="redacted"', "redacted\n"),+ (r'-DBUILD_FLAG="C:\\voice"', "C:\\voice\n"),+ ('-DBUILD_FLAG="two words"', None),+ ]+ ):+ with self.subTest(flag=flag):+ self.args.c_flag = [flag]+ self.args.output = self.root / str(index)+ build = NativeBuild(self.args, self.environment)+ with (+ patch(+ "build_native.prepare_sources",+ side_effect=lambda *args: (build.output / "build").mkdir(),+ ),+ patch.object(build, "cmake"),+ patch.object(build, "meson"),+ patch.object(build, "run") as run,+ ):+ if " " in flag:+ with self.assertRaisesRegex(ValueError, "libffi flags"):+ build.build()+ continue+ build.build()+ environment = next(+ call.kwargs["environment"]+ for call in run.call_args_list+ if call.args[0] == "libffi-configure"+ )+ (build.output / "probe.c").write_text(+ "#include <stdio.h>\nint main(void) { puts(BUILD_FLAG); }\n"+ )+ subprocess.run(+ ["/bin/sh", "-c", "$CC $CFLAGS probe.c -o probe"],+ cwd=build.output,+ env=environment,+ check=True,+ )+ result = subprocess.run(+ [build.output / "probe"], check=True, capture_output=True, text=True+ )+ self.assertEqual(result.stdout, expected)+ (build.output / "Makefile").write_text(+ f"CC={compiler}\nCFLAGS={environment['CFLAGS']} -fexceptions\n"+ "MAKEOVERRIDES=\nall:\n\t$(MAKE) nested\n"+ "nested:\n\t$(CC) $(CFLAGS) probe.c -o probe\n\t./probe\n"+ )+ result = subprocess.run(+ [make, "--silent"],+ cwd=build.output,+ check=True,+ capture_output=True,+ text=True,+ )+ self.assertEqual(result.stdout, expected)@unittest.skipIf(os.name == "nt", "Unix install paths; Windows layout is unchanged")def test_cmake_installs_relative_library_paths(self):@@ -130,11 +244,13 @@ class NativeBuildTests(unittest.TestCase):setattr(self.args, argument, Path(shutil.which(tool)))source = self.root / "library-source"source.mkdir()+ self.args.c_flag = ["-DBUILD_FLAG=42"]+ self.args.link_flag = ["-Wl,-rpath,declared-relative-path"](source / "CMakeLists.txt").write_text("cmake_minimum_required(VERSION 3.15)\nproject(relative_paths LANGUAGES C)\n""add_library(fixture SHARED fixture.c)\ninstall(TARGETS fixture DESTINATION lib)\n")- (source / "fixture.c").write_text("int fixture(void) { return 42; }\n")+ (source / "fixture.c").write_text("int fixture(void) { return BUILD_FLAG; }\n")build = NativeBuild(self.args, self.environment)build.output.mkdir()build.sources = {"fixture": source}@@ -145,14 +261,15 @@ class NativeBuildTests(unittest.TestCase):metadata = inspect(build.tools / "lib/libfixture.dylib", self.args.target)self.assertEqual((metadata.identity, metadata.rpaths),- ("@rpath/libfixture.dylib", ("@loader_path",)),+ ("@rpath/libfixture.dylib", ("declared-relative-path", "@loader_path")),)else:from linux_runtime import inspectmetadata = inspect(build.tools / "lib/libfixture.so", self.args.target)self.assertEqual(- (metadata.identity, metadata.rpaths), ("libfixture.so", ("29=$ORIGIN",))+ (metadata.identity, metadata.rpaths),+ ("libfixture.so", ("29=declared-relative-path:$ORIGIN",)),)def test_build_refuses_existing_output_before_reading_sources(self):@@ -184,6 +301,7 @@ class NativeBuildTests(unittest.TestCase):{"target": self.args.target,"deployment_target": "11.0",+ "flags": {"CFLAGS": [], "CXXFLAGS": [], "LDFLAGS": []},"steps": [{"name": "failure", "command": command, "exit_code": 23}],},)@@ -203,22 +321,64 @@ class NativeBuildTests(unittest.TestCase):self.assertEqual(environment["PKG_CONFIG_PATH"], "")def test_meson_receives_private_link_inputs_with_spaces(self):+ if platform.system() == "Darwin":+ self.args.cc = Path(shutil.which("cc"))+ self.args.c_flag = [] if os.name == "nt" else ["-DDECLARED_C=1"]+ self.args.cxx_flag = [] if os.name == "nt" else ["-DDECLARED_CXX=1"]+ self.args.link_flag = (+ [] if os.name == "nt" else ["-Ldeclared input with spaces"]+ )build = NativeBuild(self.args, self.environment)+ self.assertEqual(+ build.record["flags"],+ {+ "CFLAGS": self.args.c_flag,+ "CXXFLAGS": self.args.cxx_flag,+ "LDFLAGS": self.args.link_flag,+ },+ )build.sources = {"meson": self.root / "meson", "glib": self.root / "glib"}with patch.object(build, "run"):build.meson("glib", [])+ if platform.system() == "Darwin":+ subprocess.run(+ [+ build.environment["OBJC"],+ *shlex.split(build.environment["OBJCFLAGS"]),+ "-x",+ "objective-c",+ "-fsyntax-only",+ "-",+ ],+ input="#if DECLARED_C != 1\n#error missing declared flags\n#endif\n",+ text=True,+ check=True,+ )+ quote = subprocess.list2cmdline if build.windows else shlex.join+ include = f"{'/I' if build.windows else '-I'}{build.prefix / 'include'}"+ self.assertEqual(+ {name: build.environment[name] for name in ("CFLAGS", "CXXFLAGS")},+ {+ "CFLAGS": quote([*self.args.c_flag, include]),+ "CXXFLAGS": quote([*self.args.cxx_flag, include]),+ },+ )if build.windows:self.assertEqual(- build.environment["LDFLAGS"], f'"/LIBPATH:{build.prefix / "lib"}"'+ build.environment["LDFLAGS"],+ quote([*self.args.link_flag, f"/LIBPATH:{build.prefix / 'lib'}"]),)else:self.assertEqual(shlex.split(build.environment["LDFLAGS"]),[+ *self.args.link_flag,f"-L{build.prefix / 'lib'}",- "-Wl,-rpath,$ORIGIN:$ORIGIN/.."- if build.args.target.endswith("unknown-linux-gnu")- else f"-Wl,-rpath,{build.prefix / 'lib'}",+ (+ "-Wl,-rpath,$ORIGIN:$ORIGIN/.."+ if build.args.target.endswith("unknown-linux-gnu")+ else f"-Wl,-rpath,{build.prefix / 'lib'}"+ ),],)@@ -242,6 +402,19 @@ class NativeBuildTests(unittest.TestCase):with self.assertRaises(subprocess.CalledProcessError):build.posix_path(path)+ def test_windows_rejects_unix_overrides_before_creating_output(self):+ self.args.target = "x86_64-pc-windows-msvc"+ for name, value in (+ ("c_flag", [r"/IC:\SDK\include"]),+ ("ranlib", Path(sys.executable)),+ ):+ with patch("build_native.validate_target"):+ setattr(self.args, name, value)+ with self.assertRaisesRegex(ValueError, "Unix build host"):+ NativeBuild(self.args, self.environment)+ delattr(self.args, name)+ self.assertFalse(self.args.output.exists())+def test_windows_recipes_use_explicit_targets_and_posix_paths(self):self.environment["USERPROFILE"] = str(self.root / "user profile")for architecture, flag in (("x86_64", "-m64"), ("aarch64", "-marm64")):