refactor(pumpkin-solver): Use the fzn-rs package instead of flatzinc

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["./pumpkin-solver", "./drcp-format", "./pumpkin-solver-py", "./pumpkin-macros", "./drcp-debugger", "./pumpkin-crates/*"]
+members = ["./pumpkin-solver", "./drcp-format", "./pumpkin-solver-py", "./pumpkin-macros", "./drcp-debugger", "./pumpkin-crates/*", "./fzn-rs", "fzn-rs-derive"]
 default-members = ["./pumpkin-solver", "./drcp-format", "./pumpkin-solver-py", "./pumpkin-macros"]
 resolver = "2"
 

clippy.toml

@@ -1 +1 @@
-allowed-duplicate-crates = ["regex-automata", "regex-syntax"]
+allowed-duplicate-crates = ["regex-automata", "regex-syntax", "convert_case"]

fzn-rs-derive/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "fzn-rs-derive"
+version = "0.1.0"
+repository.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+convert_case = "0.8.0"
+proc-macro2 = "1.0.95"
+quote = "1.0.40"
+syn = { version = "2.0.104", features = ["extra-traits"] }
+
+[dev-dependencies]
+fzn-rs = { path = "../fzn-rs/" }
+
+[lints]
+workspace = true

fzn-rs-derive/src/annotation.rs

@@ -0,0 +1,114 @@
+use quote::quote;
+
+/// Construct a token stream that initialises a value with name `value_type` and the arguments
+/// described in `fields`.
+pub(crate) fn initialise_value(
+    value_type: &syn::Ident,
+    fields: &syn::Fields,
+) -> proc_macro2::TokenStream {
+    // For every field, initialise the value for that field.
+    let field_values = fields.iter().enumerate().map(|(idx, field)| {
+        let ty = &field.ty;
+
+        // If the field has a name, then prepend the field value with the name: `name: value`.
+        let value_prefix = if let Some(ident) = &field.ident {
+            quote! { #ident: }
+        } else {
+            quote! {}
+        };
+
+        // If there is an `#[annotation]` attribute on the field, then the value is the result of
+        // parsing a nested annotation. Otherwise, we look at the type of the field
+        // and parse the value corresponding to that type.
+        if field.attrs.iter().any(|attr| {
+            attr.path()
+                .get_ident()
+                .is_some_and(|ident| ident == "annotation")
+        }) {
+            quote! {
+                #value_prefix <#ty as ::fzn_rs::FromNestedAnnotation>::from_argument(
+                    &arguments[#idx],
+                )?
+            }
+        } else {
+            quote! {
+                #value_prefix <#ty as ::fzn_rs::FromAnnotationArgument>::from_argument(
+                    &arguments[#idx],
+                )?
+            }
+        }
+    });
+
+    // Complete the value initialiser by prepending the type name to the field values.
+    let value_initialiser = match fields {
+        syn::Fields::Named(_) => quote! { #value_type { #(#field_values),* } },
+        syn::Fields::Unnamed(_) => quote! { #value_type ( #(#field_values),* ) },
+        syn::Fields::Unit => quote! { #value_type },
+    };
+
+    let num_arguments = fields.len();
+
+    // Output the final initialisation, with checking of number of arguments.
+    quote! {
+        if arguments.len() != #num_arguments {
+            return Err(::fzn_rs::InstanceError::IncorrectNumberOfArguments {
+                expected: #num_arguments,
+                actual: arguments.len(),
+                span: annotation.span,
+            });
+        }
+
+        Ok(Some(#value_initialiser))
+    }
+}
+
+/// Create the parsing code for one annotation corresponding to the given variant.
+pub(crate) fn variant_to_annotation(variant: &syn::Variant) -> proc_macro2::TokenStream {
+    // Determine the flatzinc annotation name.
+    let name = match crate::common::get_explicit_name(variant) {
+        Ok(name) => name,
+        Err(_) => {
+            return quote! {
+                compile_error!("Invalid usage of #[name(...)]");
+            }
+        }
+    };
+
+    let variant_name = &variant.ident;
+
+    // If variant argument is a struct, then delegate parsing of the annotation arguments to that
+    // struct.
+    if let Some(constraint_type) = crate::common::get_args_type(variant) {
+        return quote! {
+            ::fzn_rs::ast::Annotation::Call(::fzn_rs::ast::AnnotationCall {
+                name,
+                arguments,
+            }) if name.as_ref() == #name => {
+                let args = <#constraint_type as ::fzn_rs::FlatZincAnnotation>::from_ast_required(annotation)?;
+                let value = #variant_name(args);
+                Ok(Some(value))
+            }
+        };
+    }
+
+    // If the variant has no arguments, parse an atom annotaton. Otherwise, initialise the values
+    // of the variant arguments.
+    if matches!(variant.fields, syn::Fields::Unit) {
+        quote! {
+            ::fzn_rs::ast::Annotation::Atom(ident) if ident.as_ref() == #name => {
+                Ok(Some(#variant_name))
+            }
+        }
+    } else {
+        let value = initialise_value(&variant.ident, &variant.fields);
+
+        quote! {
+            ::fzn_rs::ast::Annotation::Call(::fzn_rs::ast::AnnotationCall {
+                name,
+                arguments,
+            }) if name.as_ref() == #name => {
+                #value
+            }
+        }
+    }
+}

fzn-rs-derive/src/common.rs

@@ -0,0 +1,55 @@
+use convert_case::Case;
+use convert_case::Casing;
+
+/// Get the name of the constraint or annotation from the variant. This either is converting the
+/// variant name to snake case, or retrieving the value from the `#[name(...)]` attribute.
+pub(crate) fn get_explicit_name(variant: &syn::Variant) -> syn::Result<String> {
+    variant
+        .attrs
+        .iter()
+        // Find the attribute with a `name` as the path.
+        .find(|attr| attr.path().get_ident().is_some_and(|ident| ident == "name"))
+        // Parse the arguments of the attribute to a string literal.
+        .map(|attr| {
+            attr.parse_args::<syn::LitStr>()
+                .map(|string_lit| string_lit.value())
+        })
+        // If no `name` attribute exists, return the snake-case version of the variant name.
+        .unwrap_or_else(|| Ok(variant.ident.to_string().to_case(Case::Snake)))
+}
+
+/// Returns the type of the arguments for the variant if the variant has exactly the following
+/// shape:
+///
+/// ```ignore
+/// #[args]
+/// Variant(Type)
+/// ```
+pub(crate) fn get_args_type(variant: &syn::Variant) -> Option<&syn::Type> {
+    let has_args_attr = variant
+        .attrs
+        .iter()
+        .any(|attr| attr.path().get_ident().is_some_and(|ident| ident == "args"));
+
+    if !has_args_attr {
+        return None;
+    }
+
+    if variant.fields.len() != 1 {
+        // If there is not exactly one argument for this variant, then it cannot be a struct
+        // constraint.
+        return None;
+    }
+
+    let field = variant
+        .fields
+        .iter()
+        .next()
+        .expect("there is exactly one field");
+
+    if field.ident.is_none() {
+        Some(&field.ty)
+    } else {
+        None
+    }
+}