macros: DeserializeValue uses Flavor

Instead of taking `enforce_order` as boolean flag, DeserializeValue now
takes a string (e.g., `flavor = "enforce_order"`) and converts it to
a variant of the Flavor enum. This way DeserializeValue is unified with
SerializeValue wrt flavor selection.

Author: wprzytula

scylla-cql/src/types/deserialize/value.rs

@@ -1963,7 +1963,7 @@ fn _test_udt_bad_attributes_skip_name_check_requires_enforce_order() {}
 /// ```compile_fail
 ///
 /// #[derive(scylla_macros::DeserializeValue)]
-/// #[scylla(crate = scylla_cql, enforce_order, skip_name_checks)]
+/// #[scylla(crate = scylla_cql, flavor = "enforce_order", skip_name_checks)]
 /// struct TestUdt {
 ///     #[scylla(rename = "b")]
 ///     a: i32,
@@ -1999,7 +1999,7 @@ fn _test_udt_bad_attributes_rename_collision_with_another_rename() {}
 /// ```compile_fail
 ///
 /// #[derive(scylla_macros::DeserializeValue)]
-/// #[scylla(crate = scylla_cql, enforce_order, skip_name_checks)]
+/// #[scylla(crate = scylla_cql, flavor = "enforce_order", skip_name_checks)]
 /// struct TestUdt {
 ///     a: i32,
 ///     #[scylla(allow_missing)]

scylla-cql/src/types/deserialize/value_tests.rs

@@ -632,7 +632,7 @@ struct TestUdtWithNoFieldsUnordered {}
 
 #[allow(unused)]
 #[derive(scylla_macros::DeserializeValue)]
-#[scylla(crate = crate, enforce_order)]
+#[scylla(crate = crate, flavor = "enforce_order")]
 struct TestUdtWithNoFieldsOrdered {}
 
 #[test]
@@ -786,7 +786,7 @@ fn test_udt_loose_ordering() {
 #[test]
 fn test_udt_strict_ordering() {
     #[derive(scylla_macros::DeserializeValue, PartialEq, Eq, Debug)]
-    #[scylla(crate = "crate", enforce_order)]
+    #[scylla(crate = "crate", flavor = "enforce_order")]
     struct Udt<'a> {
         #[scylla(default_when_null)]
         a: &'a str,
@@ -860,7 +860,7 @@ fn test_udt_strict_ordering() {
     // An excess field at the end of UDT, when such are forbidden
     {
         #[derive(scylla_macros::DeserializeValue, PartialEq, Eq, Debug)]
-        #[scylla(crate = "crate", enforce_order, forbid_excess_udt_fields)]
+        #[scylla(crate = "crate", flavor = "enforce_order", forbid_excess_udt_fields)]
         struct Udt<'a> {
             a: &'a str,
             #[scylla(skip)]
@@ -934,7 +934,7 @@ fn test_udt_strict_ordering() {
 #[test]
 fn test_udt_no_name_check() {
     #[derive(scylla_macros::DeserializeValue, PartialEq, Eq, Debug)]
-    #[scylla(crate = "crate", enforce_order, skip_name_checks)]
+    #[scylla(crate = "crate", flavor = "enforce_order", skip_name_checks)]
     struct Udt<'a> {
         a: &'a str,
         #[scylla(skip)]
@@ -1762,7 +1762,7 @@ fn test_udt_errors() {
     // Strict ordering
     {
         #[derive(scylla_macros::DeserializeValue, PartialEq, Eq, Debug)]
-        #[scylla(crate = "crate", enforce_order, forbid_excess_udt_fields)]
+        #[scylla(crate = "crate", flavor = "enforce_order", forbid_excess_udt_fields)]
         struct Udt<'a> {
             a: &'a str,
             #[scylla(skip)]

scylla-macros/src/deserialize/value.rs

@@ -5,6 +5,8 @@ use proc_macro::TokenStream;
 use proc_macro2::Span;
 use syn::{ext::IdentExt, parse_quote};
 
+use crate::Flavor;
+
 use super::{DeserializeCommonFieldAttrs, DeserializeCommonStructAttrs};
 
 #[derive(FromAttributes)]
@@ -13,12 +15,8 @@ struct StructAttrs {
     #[darling(rename = "crate")]
     crate_path: Option<syn::Path>,
 
-    // If true, then the type checking code will require the order of the fields
-    // to be the same in both the Rust struct and the UDT. This allows the
-    // deserialization to be slightly faster because looking struct fields up
-    // by name can be avoided, though it is less convenient.
     #[darling(default)]
-    enforce_order: bool,
+    flavor: Flavor,
 
     // If true, then the type checking code won't verify the UDT field names.
     // UDT fields will be matched to struct fields based solely on the order.
@@ -112,9 +110,10 @@ fn validate_attrs(attrs: &StructAttrs, fields: &[Field]) -> Result<(), darling::
 
     if attrs.skip_name_checks {
         // Skipping name checks is only available in enforce_order mode
-        if !attrs.enforce_order {
-            let error =
-                darling::Error::custom("attribute <skip_name_checks> requires <enforce_order>.");
+        if attrs.flavor != Flavor::EnforceOrder {
+            let error = darling::Error::custom(
+                "attribute <skip_name_checks> requires <flavor = enforce_order>.",
+            );
             errors.push(error);
         }
 
@@ -207,18 +206,16 @@ impl StructDesc {
     }
 
     fn generate_type_check_method(&self) -> syn::ImplItemFn {
-        if self.attrs.enforce_order {
-            TypeCheckAssumeOrderGenerator(self).generate()
-        } else {
-            TypeCheckUnorderedGenerator(self).generate()
+        match self.attrs.flavor {
+            Flavor::MatchByName => TypeCheckUnorderedGenerator(self).generate(),
+            Flavor::EnforceOrder => TypeCheckAssumeOrderGenerator(self).generate(),
         }
     }
 
     fn generate_deserialize_method(&self) -> syn::ImplItemFn {
-        if self.attrs.enforce_order {
-            DeserializeAssumeOrderGenerator(self).generate()
-        } else {
-            DeserializeUnorderedGenerator(self).generate()
+        match self.attrs.flavor {
+            Flavor::MatchByName => DeserializeUnorderedGenerator(self).generate(),
+            Flavor::EnforceOrder => DeserializeAssumeOrderGenerator(self).generate(),
         }
     }
 }

scylla/src/macros.rs

@@ -307,20 +307,26 @@ pub use scylla_cql::macros::SerializeRow;
 /// macro itself, so in those cases the user must provide an alternative path
 /// to either the `scylla` or `scylla-cql` crate.
 ///
-/// `#[scylla(enforce_order)]`
 ///
-/// By default, the generated deserialization code will be insensitive
-/// to the UDT field order - when processing a field, it will look it up
-/// in the Rust struct with the corresponding field and set it. However,
-/// if the UDT field order is known to be the same both in the UDT
-/// and the Rust struct, then the `enforce_order` annotation can be used
-/// so that a more efficient implementation that does not perform lookups
-/// is be generated. The UDT field names will still be checked during the
-/// type check phase.
+/// `#[scylla(flavor = "flavor_name")]`
+///
+/// Allows to choose one of the possible "flavors", i.e. the way how the
+/// generated code will approach deserialization. Possible flavors are:
+///
+/// - `"match_by_name"` (default) - the generated implementation _does not
+///   require_ the fields in the Rust struct to be in the same order as the
+///   fields in the UDT. During deserialization, the implementation will take
+///   care to deserialize the fields in the order which the database expects.
+/// - `"enforce_order"` - the generated implementation _requires_ the fields
+///   in the Rust struct to be in the same order as the fields in the UDT.
+///   If the order is incorrect, type checking/deserialization will fail.
+///   This is a less robust flavor than `"match_by_name"`, but should be
+///   slightly more performant as it doesn't need to perform lookups by name.
+///   The UDT field names will still be checked during the type check phase.
 ///
 /// #[(scylla(skip_name_checks))]
 ///
-/// This attribute only works when used with `enforce_order`.
+/// This attribute only works when used with `flavor = "enforce_order"`.
 ///
 /// If set, the generated implementation will not verify the UDT field names at
 /// all. Because it only works with `enforce_order`, it will deserialize first