Add index attribute for explicit index assignment

Fixes: #17

Author: robin-nitrokey

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Prefer explicit indexing over automatically assigned indices:
   - Require `auto_index` attribute to enable automatic index assignment
+  - Add `index` attribute for explicit index assignment
 
 ## [v0.1.1][] (2024-04-03)
 

src/lib.rs

@@ -8,11 +8,12 @@ and a custom `offset` container attribute.
 use serde_indexed::{DeserializeIndexed, SerializeIndexed};
 
 #[derive(Clone, Debug, PartialEq, SerializeIndexed, DeserializeIndexed)]
-#[serde_indexed(auto_index, offset = 1)]
 pub struct SomeKeys {
+    #[serde(index = 1)]
     pub number: i32,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(index = 2, skip_serializing_if = "Option::is_none")]
     pub option: Option<u8>,
+    #[serde(index = 3)]
     pub bytes: [u8; 7],
 }
 ```

src/parse.rs

@@ -93,12 +93,19 @@ impl Parse for Input {
     }
 }
 
-fn parse_field<T: ToTokens + Copy>(span: T, i: usize, field: &syn::Field) -> Result<Field> {
+fn parse_field<T: ToTokens + Copy>(
+    span: T,
+    attrs: &StructAttrs,
+    i: usize,
+    field: &syn::Field,
+    indices: &mut Vec<usize>,
+) -> Result<Field> {
     let ident = field
         .ident
         .as_ref()
         .ok_or_else(|| Error::new_spanned(span, "Tuple structs are not supported"))?;
     let mut skip_serializing_if = None;
+    let mut index = None;
     for attr in &field.attrs {
         if attr.path().is_ident("serde") {
             attr.parse_nested_meta(|meta| {
@@ -110,16 +117,43 @@ fn parse_field<T: ToTokens + Copy>(span: T, i: usize, field: &syn::Field) -> Res
                     }
                     skip_serializing_if = Some(syn::parse2(tokens)?);
                     Ok(())
+                } else if meta.path.is_ident("index") {
+                    if index.is_some() {
+                        return Err(meta.error("Multiple attributes for index"));
+                    }
+                    if attrs.auto_index {
+                        return Err(meta.error(
+                            "The index attribute cannot be combined with the auto_index attribute",
+                        ));
+                    }
+                    let litint: LitInt = meta.value()?.parse()?;
+                    let int = litint.base10_parse()?;
+                    if indices.contains(&int) {
+                        return Err(meta.error("This index has already been assigned"));
+                    }
+                    index = Some(int);
+                    Ok(())
                 } else {
                     Err(meta.error("Unkown field attribute"))
                 }
             })?;
         }
     }
+    let index = if attrs.auto_index {
+        i
+    } else if let Some(index) = index {
+        indices.push(index);
+        index
+    } else {
+        return Err(Error::new_spanned(
+            span,
+            "Field without index attribute and auto_index is not set",
+        ));
+    };
     Ok(Field {
         label: ident.to_string(),
         member: syn::Member::Named(ident.clone()),
-        index: i,
+        index,
         skip_serializing_if,
     })
 }
@@ -128,17 +162,11 @@ fn fields_from_ast(
     attrs: &StructAttrs,
     fields: &syn::punctuated::Punctuated<syn::Field, Token![,]>,
 ) -> Result<Vec<Field>> {
-    if !attrs.auto_index {
-        return Err(Error::new_spanned(
-            fields,
-            "auto_index attribute must be set",
-        ));
-    }
-
     // serde::internals::ast.rs:L183
+    let mut indices = Vec::new();
     fields
         .iter()
         .enumerate()
-        .map(|(i, field)| parse_field(fields, i, field))
+        .map(|(i, field)| parse_field(fields, &attrs, i, field, &mut indices))
         .collect()
 }

tests/basics.rs

@@ -487,3 +487,42 @@ mod generics {
         assert_eq!(deserialized, example);
     }
 }
+
+mod index {
+    use super::*;
+
+    #[derive(PartialEq, Debug, SerializeIndexed, DeserializeIndexed)]
+    struct WithIndices {
+        #[serde(index = 9)]
+        test1: usize,
+        #[serde(index = 2)]
+        test2: usize,
+        #[serde(index = 5)]
+        test3: usize,
+    }
+
+    fn indices_example() -> WithIndices {
+        WithIndices {
+            test1: 42,
+            test2: 1,
+            test3: 99,
+        }
+    }
+
+    #[test]
+    fn tokens() {
+        assert_tokens(
+            &indices_example(),
+            &[
+                Token::Map { len: Some(3) },
+                Token::U64(9),
+                Token::U64(42),
+                Token::U64(2),
+                Token::U64(1),
+                Token::U64(5),
+                Token::U64(99),
+                Token::MapEnd,
+            ],
+        );
+    }
+}