CMake Toolchain

Author: Behemyth

cppython/plugins/cmake/builder.py

@@ -2,7 +2,7 @@
 
 from pathlib import Path
 
-from cppython.plugins.cmake.schema import CMakeData, CMakePresets, CMakeSyncData, ConfigurePreset
+from cppython.plugins.cmake.schema import CacheVariable, CMakeData, CMakePresets, CMakeSyncData, ConfigurePreset
 
 
 class Builder:
@@ -21,10 +21,18 @@ def generate_provider_preset(provider_data: CMakeSyncData) -> CMakePresets:
         """
         generated_configure_preset = ConfigurePreset(name=provider_data.provider_name, hidden=True)
 
-        # Toss in that sync data from the provider
-        generated_configure_preset.cacheVariables = {
-            'CMAKE_PROJECT_TOP_LEVEL_INCLUDES': str(provider_data.top_level_includes.as_posix()),
-        }
+        # Handle both top_level_includes and toolchain options
+        cache_variables: dict[str, str | bool | CacheVariable | None] = {}
+
+        if provider_data.top_level_includes:
+            cache_variables['CMAKE_PROJECT_TOP_LEVEL_INCLUDES'] = str(provider_data.top_level_includes.as_posix())
+
+        if provider_data.toolchain:
+            # Use the toolchainFile field for better integration
+            generated_configure_preset.toolchainFile = provider_data.toolchain
+
+        if cache_variables:
+            generated_configure_preset.cacheVariables = cache_variables
 
         return CMakePresets(configurePresets=[generated_configure_preset])
 

cppython/plugins/cmake/schema.py

@@ -58,6 +58,10 @@ class ConfigurePreset(CPPythonModel, extra='allow'):
         str | None,
         Field(description='The path to the output binary directory.'),
     ] = None
+    toolchainFile: Annotated[
+        Path | None,
+        Field(description='Path to the toolchain file.'),
+    ] = None
     cacheVariables: dict[str, None | bool | str | CacheVariable] | None = None
 
 
@@ -77,7 +81,13 @@ class CMakePresets(CPPythonModel, extra='allow'):
 class CMakeSyncData(SyncData):
     """The CMake sync data"""
 
-    top_level_includes: FilePath
+    top_level_includes: FilePath | None = None
+    toolchain: Path | None = None  # We don't resolve the toolchain until after we set it
+
+    def model_post_init(self, __context) -> None:
+        """Validate that at least one of top_level_includes or toolchain is provided."""
+        if not self.top_level_includes and not self.toolchain:
+            raise ValueError("Either 'top_level_includes' or 'toolchain' must be provided")
 
 
 class CMakeData(CPPythonModel):

cppython/plugins/conan/builder.py

@@ -125,7 +125,7 @@ def _create_conanfile(conan_file: Path, dependencies: list[ConanDependency], nam
         """Creates a conanfile.py file with the necessary content."""
         template_string = """
         from conan import ConanFile
-        from conan.tools.cmake import CMake, CMakeDeps, cmake_layout
+        from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
 
         class AutoPackage(ConanFile):
             name = "${name}"
@@ -139,6 +139,8 @@ def layout(self):
             def generate(self):
                 deps = CMakeDeps(self)
                 deps.generate()
+                tc = CMakeToolchain(self)
+                tc.generate()
 
             def build(self):
                 cmake = CMake(self)

cppython/plugins/conan/plugin.py

@@ -8,7 +8,6 @@
 from pathlib import Path
 from typing import Any
 
-import requests
 from conan.api.conan_api import ConanAPI
 from conan.api.model import ListPattern
 
@@ -27,8 +26,6 @@
 class ConanProvider(Provider):
     """Conan Provider"""
 
-    _provider_url = 'https://raw.githubusercontent.com/conan-io/cmake-conan/refs/heads/develop2/conan_provider.cmake'
-
     def __init__(
         self, group_data: ProviderPluginGroupData, core_data: CorePluginData, configuration_data: dict[str, Any]
     ) -> None:
@@ -39,15 +36,6 @@ def __init__(
 
         self.builder = Builder()
 
-    @staticmethod
-    def _download_file(url: str, file: Path) -> None:
-        """Replaces the given file with the contents of the url"""
-        file.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(file, 'wb') as out_file:
-            content = requests.get(url, stream=True).content
-            out_file.write(content)
-
     @staticmethod
     def features(directory: Path) -> SupportedFeatures:
         """Queries conan support
@@ -197,6 +185,13 @@ def _generate_consumer_files(self, conan_api: ConanAPI, deps_graph) -> None:
             output_folder=str(self.core_data.cppython_data.build_path),
         )
 
+        # Rename the generated toolchain file so our wrapper can include it
+        original_toolchain = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake'
+        renamed_toolchain = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake.real'
+
+        if original_toolchain.exists() and not renamed_toolchain.exists():
+            original_toolchain.rename(renamed_toolchain)
+
     def install(self) -> None:
         """Installs the provider"""
         self._install_dependencies(update=False)
@@ -231,17 +226,25 @@ def sync_data(self, consumer: SyncConsumer) -> SyncData:
         """
         for sync_type in consumer.sync_types():
             if sync_type == CMakeSyncData:
+                # Use the CMakeToolchain file directly as the toolchain
+                toolchain_path = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake'
+
                 return CMakeSyncData(
                     provider_name=TypeName('conan'),
-                    top_level_includes=self.core_data.cppython_data.install_path / 'conan_provider.cmake',
+                    toolchain=toolchain_path,
                 )
 
         raise NotSupportedError(f'Unsupported sync types: {consumer.sync_types()}')
 
     @classmethod
     async def download_tooling(cls, directory: Path) -> None:
-        """Downloads the conan provider file"""
-        cls._download_file(cls._provider_url, directory / 'conan_provider.cmake')
+        """Download external tooling required by the Conan provider.
+
+        Since we're using CMakeToolchain generator instead of cmake-conan provider,
+        no external tooling needs to be downloaded.
+        """
+        # No external tooling required when using CMakeToolchain
+        pass
 
     def publish(self) -> None:
         """Publishes the package using conan create workflow."""