hatch-cpp 0.3.5__tar.gz → 0.3.6__tar.gz

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-cpp
-Version: 0.3.5
+Version: 0.3.6
 Summary: Hatch plugin for C++ builds
 Project-URL: Repository, https://github.com/python-project-templates/hatch-cpp
 Project-URL: Homepage, https://github.com/python-project-templates/hatch-cpp
@@ -33,7 +33,7 @@ Requires-Dist: hatch-build>=0.3.2; extra == 'develop'
 Requires-Dist: hatchling; extra == 'develop'
 Requires-Dist: mdformat; extra == 'develop'
 Requires-Dist: mdformat-tables>=1; extra == 'develop'
-Requires-Dist: nanobind<2.12.0; extra == 'develop'
+Requires-Dist: nanobind<2.13.0; extra == 'develop'
 Requires-Dist: pybind11; extra == 'develop'
 Requires-Dist: pytest; extra == 'develop'
 Requires-Dist: pytest-cov; extra == 'develop'

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/hatch_cpp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.5"
+__version__ = "0.3.6"
 
 from .config import *
 from .hooks import *

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/hatch_cpp/config.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from os import system as system_call
+from os import environ, system as system_call
 from pathlib import Path
 from typing import List, Optional
 
@@ -63,12 +63,27 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
     def generate(self):
         self.commands = []
 
+        # Check for env var overrides
+        vcpkg_override = environ.get("HATCH_CPP_VCPKG")
+        cmake_override = environ.get("HATCH_CPP_CMAKE")
+
         # Evaluate toolchains
-        if self.vcpkg and Path(self.vcpkg.vcpkg).exists():
+        if vcpkg_override == "1":
+            if self.vcpkg:
+                self._active_toolchains.append("vcpkg")
+            else:
+                log.warning("HATCH_CPP_VCPKG=1 set but no vcpkg configuration found; ignoring.")
+        elif vcpkg_override != "0" and self.vcpkg and Path(self.vcpkg.vcpkg).exists():
             self._active_toolchains.append("vcpkg")
+
         if self.libraries:
             self._active_toolchains.append("vanilla")
-        elif self.cmake:
+        elif cmake_override == "1":
+            if self.cmake:
+                self._active_toolchains.append("cmake")
+            else:
+                log.warning("HATCH_CPP_CMAKE=1 set but no cmake configuration found; ignoring.")
+        elif cmake_override != "0" and self.cmake:
             self._active_toolchains.append("cmake")
 
         # Collect toolchain commands

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/hatch_cpp/tests/test_platform_specific.py

@@ -345,7 +345,7 @@ class TestPlatformFlagsIntegration:
 
         flags = platform.get_link_flags(library)
         assert "-shared" in flags
-        assert "-Wl,-rpath,$ORIGIN/lib" in flags
+        assert r"-Wl,-rpath,\$ORIGIN/lib" in flags
 
     def test_darwin_platform_uses_darwin_specific_fields(self):
         """Test that darwin platform uses darwin-specific fields."""

hatch_cpp-0.3.6/hatch_cpp/tests/test_structs.py

@@ -0,0 +1,240 @@
+from os import environ
+from pathlib import Path
+from sys import version_info
+from unittest.mock import patch
+
+import pytest
+from pydantic import ValidationError
+from toml import loads
+
+from hatch_cpp import HatchCppBuildConfig, HatchCppBuildPlan, HatchCppLibrary, HatchCppPlatform
+from hatch_cpp.toolchains.common import _normalize_rpath
+
+
+class TestStructs:
+    def test_validate_py_limited_api(self):
+        with pytest.raises(ValidationError):
+            library = HatchCppLibrary(
+                name="test",
+                sources=["test.cpp"],
+                py_limited_api="42",
+            )
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            py_limited_api="cp39",
+        )
+        assert library.py_limited_api == "cp39"
+        platform = HatchCppPlatform.default()
+        flags = platform.get_compile_flags(library)
+        assert "-DPy_LIMITED_API=0x030900f0" in flags or "/DPy_LIMITED_API=0x030900f0" in flags
+
+        with pytest.raises(ValidationError):
+            library.binding = "pybind11"
+
+    def test_cmake_args(self):
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml["project"]["name"], **toml["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+        hatch_build_plan.generate()
+
+        assert hatch_build_plan.commands[0].startswith("cmake .")
+        assert hatch_build_plan.commands[1].startswith("cmake --build build")
+        assert hatch_build_plan.commands[2].startswith("cmake --install build")
+
+        assert "-DCMAKE_BUILD_TYPE=release" in hatch_build_plan.commands[0]
+        assert "-B build" in hatch_build_plan.commands[0]
+        assert "-DHATCH_CPP_TEST_PROJECT_BASIC_BUILD_TESTS=OFF" in hatch_build_plan.commands[0]
+        assert f"-DHATCH_CPP_TEST_PROJECT_BASIC_PYTHON_VERSION=3.{version_info.minor}" in hatch_build_plan.commands[0]
+        if hatch_build_plan.platform.platform == "darwin":
+            assert "-DCMAKE_OSX_DEPLOYMENT_TARGET=11" in hatch_build_plan.commands[0]
+
+    def test_platform_toolchain_override(self):
+        txt = (Path(__file__).parent / "test_project_override_toolchain" / "pyproject.toml").read_text()
+        toml = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml["project"]["name"], **toml["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        assert "clang" in hatch_build_config.platform.cc
+        assert "clang++" in hatch_build_config.platform.cxx
+        assert hatch_build_config.platform.toolchain == "gcc"
+
+    def test_cmake_args_env_variable(self):
+        """Test that CMAKE_ARGS environment variable is respected."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_ARGS": "-DFOO=bar -DBAZ=qux"}):
+            hatch_build_plan.generate()
+            assert "-DFOO=bar" in hatch_build_plan.commands[0]
+            assert "-DBAZ=qux" in hatch_build_plan.commands[0]
+
+    def test_cmake_args_env_variable_empty(self):
+        """Test that an empty CMAKE_ARGS does not add extra whitespace."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_ARGS": ""}):
+            hatch_build_plan.generate()
+            # Should not have trailing whitespace from empty CMAKE_ARGS
+            assert not hatch_build_plan.commands[0].endswith(" ")
+
+    def test_cmake_generator_env_variable(self):
+        """Test that CMAKE_GENERATOR environment variable is respected on non-Windows platforms."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_GENERATOR": "Ninja"}):
+            hatch_build_plan.generate()
+            assert '-G "Ninja"' in hatch_build_plan.commands[0]
+
+    def test_cmake_generator_env_variable_unset(self):
+        """Test that no -G flag is added on non-Windows when CMAKE_GENERATOR is not set."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {}, clear=False):
+            # Remove CMAKE_GENERATOR if present
+            environ.pop("CMAKE_GENERATOR", None)
+            hatch_build_plan.generate()
+            if hatch_build_plan.platform.platform != "win32":
+                assert "-G " not in hatch_build_plan.commands[0]
+
+    def test_hatch_cpp_cmake_env_force_off(self):
+        """Test that HATCH_CPP_CMAKE=0 disables cmake even when cmake config is present."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is not None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "0"}):
+            hatch_build_plan.generate()
+            # cmake should not be active, so no cmake commands generated
+            assert len(hatch_build_plan.commands) == 0
+            assert "cmake" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_cmake_env_force_on(self):
+        """Test that HATCH_CPP_CMAKE=1 enables cmake when cmake config is present."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is not None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "1"}):
+            hatch_build_plan.generate()
+            assert "cmake" in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_cmake_env_force_on_no_config(self):
+        """Test that HATCH_CPP_CMAKE=1 warns and skips when no cmake config exists."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        config_data = toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"].copy()
+        config_data.pop("cmake", None)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **config_data)
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "1"}):
+            hatch_build_plan.generate()
+            # cmake should NOT be activated when there's no config
+            assert "cmake" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_vcpkg_env_force_off(self):
+        """Test that HATCH_CPP_VCPKG=0 disables vcpkg even when vcpkg.json exists."""
+        txt = (Path(__file__).parent / "test_project_cmake_vcpkg" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"HATCH_CPP_VCPKG": "0"}):
+            hatch_build_plan.generate()
+            assert "vcpkg" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_vcpkg_env_force_on(self):
+        """Test that HATCH_CPP_VCPKG=1 enables vcpkg even when vcpkg.json doesn't exist."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"HATCH_CPP_VCPKG": "1"}):
+            hatch_build_plan.generate()
+            assert "vcpkg" in hatch_build_plan._active_toolchains
+
+
+class TestNormalizeRpath:
+    def test_origin_to_loader_path_on_darwin(self):
+        """$ORIGIN should be translated to @loader_path on macOS."""
+        assert _normalize_rpath("-Wl,-rpath,$ORIGIN", "darwin") == "-Wl,-rpath,@loader_path"
+
+    def test_loader_path_to_origin_on_linux(self):
+        """@loader_path should be translated to (escaped) $ORIGIN on Linux."""
+        result = _normalize_rpath("-Wl,-rpath,@loader_path", "linux")
+        assert result == r"-Wl,-rpath,\$ORIGIN"
+
+    def test_origin_escaped_on_linux(self):
+        """$ORIGIN should be escaped as \\$ORIGIN on Linux for shell safety."""
+        result = _normalize_rpath("-Wl,-rpath,$ORIGIN", "linux")
+        assert result == r"-Wl,-rpath,\$ORIGIN"
+
+    def test_already_escaped_origin_on_darwin(self):
+        """Already-escaped \\$ORIGIN should still translate to @loader_path on macOS."""
+        assert _normalize_rpath(r"-Wl,-rpath,\$ORIGIN", "darwin") == "-Wl,-rpath,@loader_path"
+
+    def test_no_rpath_unchanged(self):
+        """Args without rpath values should pass through unchanged."""
+        assert _normalize_rpath("-lfoo", "linux") == "-lfoo"
+        assert _normalize_rpath("-lfoo", "darwin") == "-lfoo"
+
+    def test_win32_no_transform(self):
+        """Windows should not transform rpath values."""
+        assert _normalize_rpath("$ORIGIN", "win32") == "$ORIGIN"
+        assert _normalize_rpath("@loader_path", "win32") == "@loader_path"
+
+    def test_link_flags_rpath_translation_darwin(self):
+        """Full integration: extra_link_args with $ORIGIN produce @loader_path on macOS."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            extra_link_args=["-Wl,-rpath,$ORIGIN"],
+        )
+        platform = HatchCppPlatform(
+            cc="clang",
+            cxx="clang++",
+            ld="ld",
+            platform="darwin",
+            toolchain="clang",
+            disable_ccache=True,
+        )
+        flags = platform.get_link_flags(library)
+        assert "@loader_path" in flags
+        assert "$ORIGIN" not in flags
+
+    def test_link_flags_rpath_escaped_linux(self):
+        """Full integration: extra_link_args with $ORIGIN are shell-escaped on Linux."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            extra_link_args=["-Wl,-rpath,$ORIGIN"],
+        )
+        platform = HatchCppPlatform(
+            cc="gcc",
+            cxx="g++",
+            ld="ld",
+            platform="linux",
+            toolchain="gcc",
+            disable_ccache=True,
+        )
+        flags = platform.get_link_flags(library)
+        assert r"\$ORIGIN" in flags

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/hatch_cpp/toolchains/cmake.py

@@ -54,9 +54,14 @@ class HatchCppCmakeConfiguration(BaseModel):
             commands[-1] += f" -DCMAKE_INSTALL_PREFIX={Path(self.root).parent}"
 
         # TODO: CMAKE_CXX_COMPILER
+        # Respect CMAKE_GENERATOR environment variable
+        cmake_generator = environ.get("CMAKE_GENERATOR", "")
         if config.platform.platform == "win32":
-            # TODO: prefix?
-            commands[-1] += f' -G "{environ.get("CMAKE_GENERATOR", "Visual Studio 17 2022")}"'
+            if not cmake_generator:
+                cmake_generator = "Visual Studio 17 2022"
+            commands[-1] += f' -G "{cmake_generator}"'
+        elif cmake_generator:
+            commands[-1] += f' -G "{cmake_generator}"'
 
         # Put in CMake flags
         args = self.cmake_args.copy()
@@ -78,6 +83,11 @@ class HatchCppCmakeConfiguration(BaseModel):
         if config.platform.platform == "darwin":
             commands[-1] += f" -DCMAKE_OSX_DEPLOYMENT_TARGET={environ.get('OSX_DEPLOYMENT_TARGET', '11')}"
 
+        # Respect CMAKE_ARGS environment variable
+        cmake_args_env = environ.get("CMAKE_ARGS", "").strip()
+        if cmake_args_env:
+            commands[-1] += " " + cmake_args_env
+
         # Append build command
         commands.append(f"cmake --build {self.build} --config {config.build_type}")
 

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/hatch_cpp/toolchains/common.py

@@ -20,6 +20,7 @@ __all__ = (
     "PlatformDefaults",
     "HatchCppLibrary",
     "HatchCppPlatform",
+    "_normalize_rpath",
 )
 
 
@@ -207,6 +208,28 @@ class HatchCppLibrary(BaseModel, validate_assignment=True):
         return macros
 
 
+def _normalize_rpath(value: str, platform: Platform) -> str:
+    r"""Translate and escape rpath values for the target platform.
+
+    - On macOS (darwin): ``$ORIGIN`` is replaced with ``@loader_path``.
+    - On Linux: ``@loader_path`` is replaced with ``$ORIGIN``, and
+      ``$ORIGIN`` is escaped as ``\$ORIGIN`` so that ``os.system()``
+      (which invokes a shell) passes it through literally.
+    - On Windows: no transformation is applied (Windows does not use
+      rpath).
+    """
+    if platform == "darwin":
+        # Handle already-escaped \$ORIGIN first, then plain $ORIGIN
+        value = value.replace(r"\$ORIGIN", "@loader_path")
+        value = value.replace("$ORIGIN", "@loader_path")
+    elif platform == "linux":
+        # Translate macOS rpath to Linux equivalent
+        value = value.replace("@loader_path", "$ORIGIN")
+        # Escape $ORIGIN for shell safety (os.system runs through bash)
+        value = value.replace("$ORIGIN", r"\$ORIGIN")
+    return value
+
+
 class HatchCppPlatform(BaseModel):
     cc: str
     cxx: str
@@ -338,6 +361,9 @@ class HatchCppPlatform(BaseModel):
         effective_libraries = library.get_effective_libraries(self.platform)
         effective_library_dirs = library.get_effective_library_dirs(self.platform)
 
+        # Normalize rpath values ($ORIGIN <-> @loader_path) and escape for shell
+        effective_link_args = [_normalize_rpath(arg, self.platform) for arg in effective_link_args]
+
         if self.toolchain == "gcc":
             flags += " -shared"
             flags += " " + " ".join(effective_link_args)

{hatch_cpp-0.3.5 → hatch_cpp-0.3.6}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 description = "Hatch plugin for C++ builds"
 readme = "README.md"
 license = { text = "Apache-2.0" }
-version = "0.3.5"
+version = "0.3.6"
 requires-python = ">=3.10"
 keywords = [
     "hatch",
@@ -62,7 +62,7 @@ develop = [
     "uv",
     "wheel",
     # test
-    "nanobind<2.12.0",  # https://github.com/wjakob/nanobind/commit/abd27e3b5565bc95f5091321f0f863fce8b5b95b
+    "nanobind<2.13.0",  # https://github.com/wjakob/nanobind/commit/abd27e3b5565bc95f5091321f0f863fce8b5b95b
     "pybind11",
     "pytest",
     "pytest-cov",
@@ -80,7 +80,7 @@ Repository = "https://github.com/python-project-templates/hatch-cpp"
 Homepage = "https://github.com/python-project-templates/hatch-cpp"
 
 [tool.bumpversion]
-current_version = "0.3.5"
+current_version = "0.3.6"
 commit = true
 tag = true
 commit_args = "-s"
@@ -100,6 +100,7 @@ branch = false
 omit = [
     "hatch_cpp/tests/integration/",
 ]
+
 [tool.coverage.report]
 exclude_also = [
     "raise NotImplementedError",

hatch_cpp-0.3.5/hatch_cpp/tests/test_structs.py

@@ -1,56 +0,0 @@
-from pathlib import Path
-from sys import version_info
-
-import pytest
-from pydantic import ValidationError
-from toml import loads
-
-from hatch_cpp import HatchCppBuildConfig, HatchCppBuildPlan, HatchCppLibrary, HatchCppPlatform
-
-
-class TestStructs:
-    def test_validate_py_limited_api(self):
-        with pytest.raises(ValidationError):
-            library = HatchCppLibrary(
-                name="test",
-                sources=["test.cpp"],
-                py_limited_api="42",
-            )
-        library = HatchCppLibrary(
-            name="test",
-            sources=["test.cpp"],
-            py_limited_api="cp39",
-        )
-        assert library.py_limited_api == "cp39"
-        platform = HatchCppPlatform.default()
-        flags = platform.get_compile_flags(library)
-        assert "-DPy_LIMITED_API=0x030900f0" in flags or "/DPy_LIMITED_API=0x030900f0" in flags
-
-        with pytest.raises(ValidationError):
-            library.binding = "pybind11"
-
-    def test_cmake_args(self):
-        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
-        toml = loads(txt)
-        hatch_build_config = HatchCppBuildConfig(name=toml["project"]["name"], **toml["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
-        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
-        hatch_build_plan.generate()
-
-        assert hatch_build_plan.commands[0].startswith("cmake .")
-        assert hatch_build_plan.commands[1].startswith("cmake --build build")
-        assert hatch_build_plan.commands[2].startswith("cmake --install build")
-
-        assert "-DCMAKE_BUILD_TYPE=release" in hatch_build_plan.commands[0]
-        assert "-B build" in hatch_build_plan.commands[0]
-        assert "-DHATCH_CPP_TEST_PROJECT_BASIC_BUILD_TESTS=OFF" in hatch_build_plan.commands[0]
-        assert f"-DHATCH_CPP_TEST_PROJECT_BASIC_PYTHON_VERSION=3.{version_info.minor}" in hatch_build_plan.commands[0]
-        if hatch_build_plan.platform.platform == "darwin":
-            assert "-DCMAKE_OSX_DEPLOYMENT_TARGET=11" in hatch_build_plan.commands[0]
-
-    def test_platform_toolchain_override(self):
-        txt = (Path(__file__).parent / "test_project_override_toolchain" / "pyproject.toml").read_text()
-        toml = loads(txt)
-        hatch_build_config = HatchCppBuildConfig(name=toml["project"]["name"], **toml["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
-        assert "clang" in hatch_build_config.platform.cc
-        assert "clang++" in hatch_build_config.platform.cxx
-        assert hatch_build_config.platform.toolchain == "gcc"