Separate build data structs from serializations (#332)

We have three versions of the build format (v1-3), where we converted
prior versions to the latest and used the latest as the actual
configuration. The downside of this approach is that every time we
introduce a new version, we have to move all utility functions, etc. to
the latest.

This change decouples the configuration that is used to generate the
build files from the concrete serializations. The core data structures
move to the top-level module and v1-v3.rs now only contain plain data
structures to (de)serialize with serde.

Author: danieldk

build2cmake/src/config/common.rs

@@ -0,0 +1,39 @@
+use eyre::Result;
+use serde::Deserialize;
+use serde_value::Value;
+
+use super::{v1, v2, v3, Build};
+
+#[derive(Debug)]
+pub enum BuildCompat {
+    V1(v1::Build),
+    V2(v2::Build),
+    V3(v3::Build),
+}
+
+impl<'de> Deserialize<'de> for BuildCompat {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = Value::deserialize(deserializer)?;
+
+        v1::Build::deserialize(value.clone())
+            .map(BuildCompat::V1)
+            .or_else(|_| v2::Build::deserialize(value.clone()).map(BuildCompat::V2))
+            .or_else(|_| v3::Build::deserialize(value.clone()).map(BuildCompat::V3))
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+impl TryFrom<BuildCompat> for Build {
+    type Error = eyre::Error;
+
+    fn try_from(compat: BuildCompat) -> Result<Self> {
+        match compat {
+            BuildCompat::V1(v1_build) => v1_build.try_into(),
+            BuildCompat::V2(v2_build) => v2_build.try_into(),
+            BuildCompat::V3(v3_build) => Ok(v3_build.into()),
+        }
+    }
+}

build2cmake/src/config/compat.rs

@@ -0,0 +1,89 @@
+use std::{collections::HashMap, sync::LazyLock};
+
+use eyre::Result;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::Backend;
+
+pub static PYTHON_DEPENDENCIES: LazyLock<PythonDependencies> =
+    LazyLock::new(|| serde_json::from_str(include_str!("../python_dependencies.json")).unwrap());
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[non_exhaustive]
+#[serde(rename_all = "lowercase")]
+pub enum Dependency {
+    #[serde(rename = "cutlass_2_10")]
+    Cutlass2_10,
+    #[serde(rename = "cutlass_3_5")]
+    Cutlass3_5,
+    #[serde(rename = "cutlass_3_6")]
+    Cutlass3_6,
+    #[serde(rename = "cutlass_3_8")]
+    Cutlass3_8,
+    #[serde(rename = "cutlass_3_9")]
+    Cutlass3_9,
+    #[serde(rename = "cutlass_4_0")]
+    Cutlass4_0,
+    #[serde(rename = "cutlass_sycl")]
+    CutlassSycl,
+    #[serde(rename = "metal-cpp")]
+    MetalCpp,
+    Torch,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct PythonDependencies {
+    general: HashMap<String, PythonDependency>,
+    backends: HashMap<Backend, HashMap<String, PythonDependency>>,
+}
+
+impl PythonDependencies {
+    pub fn get_dependency(&self, dependency: &str) -> Result<&[String], DependencyError> {
+        match self.general.get(dependency) {
+            None => Err(DependencyError::GeneralDependency {
+                dependency: dependency.to_string(),
+            }),
+            Some(dep) => Ok(&dep.python),
+        }
+    }
+
+    pub fn get_backend_dependency(
+        &self,
+        backend: Backend,
+        dependency: &str,
+    ) -> Result<&[String], DependencyError> {
+        let backend_deps = match self.backends.get(&backend) {
+            None => {
+                return Err(DependencyError::Backend {
+                    backend: backend.to_string(),
+                })
+            }
+            Some(backend_deps) => backend_deps,
+        };
+        match backend_deps.get(dependency) {
+            None => Err(DependencyError::Dependency {
+                backend: backend.to_string(),
+                dependency: dependency.to_string(),
+            }),
+            Some(dep) => Ok(&dep.python),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct PythonDependency {
+    nix: Vec<String>,
+    python: Vec<String>,
+}
+
+#[derive(Debug, Error)]
+pub enum DependencyError {
+    #[error("No dependencies are defined for backend: {backend:?}")]
+    Backend { backend: String },
+    #[error("Unknown dependency `{dependency:?}` for backend `{backend:?}`")]
+    Dependency { backend: String, dependency: String },
+    #[error("Unknown dependency: `{dependency:?}`")]
+    GeneralDependency { dependency: String },
+}