Remove legacy standard stock config surface

Author: blackopsrepl

crates/solverforge-cvrp/src/lib.rs

@@ -49,7 +49,7 @@ pub trait VrpSolution {
 }
 
 /* ============================================================================
-Free functions (callable as fn-pointer fields in ListSpec)
+Free functions (callable as fn-pointer fields in list stock hooks)
 ============================================================================
 */
 

crates/solverforge-macros/WIREFRAME.md

@@ -55,6 +55,7 @@ Applies to structs. Adds derives: `Clone, Debug, PartialEq, Eq, ProblemFactImpl`
 - `impl PlanningEntity for T` — `is_pinned()`, `as_any()`, `as_any_mut()`
 - `impl PlanningId for T` (if `#[planning_id]` present) — `type Id` set to field type, `planning_id()` returns field value
 - `impl T { pub fn entity_descriptor(solution_field: &'static str) -> EntityDescriptor }` — builds descriptor with all variable descriptors (genuine, list, shadow) and preserves `#[planning_id]` / `#[planning_pin]` metadata
+- `pub trait {Entity}UnassignedFilter<...>` (when the entity has exactly one `Option<_>` planning variable) — `.unassigned()` on `UniConstraintStream<_, Entity, ...>`
 
 ### `PlanningSolutionImpl`
 
@@ -96,14 +97,12 @@ Applies to structs. Adds derives: `Clone, Debug, PartialEq, Eq, ProblemFactImpl`
 - `impl T { pub fn descriptor() -> SolutionDescriptor }` — builds full descriptor with entity extractors and fact extractors, reusing entity-generated descriptors so field-level variable metadata is preserved
 - `impl T { pub fn entity_count(&Self, descriptor_index: usize) -> usize }` — entity count by descriptor index
 - List operations (when list shadow support is configured): `list_len()`, `list_len_static()`, `list_remove()`, `list_insert()`, `list_get()`, `list_set()`, `list_reverse()`, `sublist_remove()`, `sublist_insert()`, `ruin_remove()`, `ruin_insert()`, `list_remove_for_construction()`, `index_to_element_static()`, `list_variable_descriptor_index()`, `element_count()`, `assigned_elements()`, `n_entities()`, `assign_element()`
-- Standard variable operations (legacy stock path only): `standard_get_variable()`, `standard_set_variable()`, `standard_value_count()`, `standard_entity_count()`, `standard_variable_descriptor_index()`, `standard_variable_field_name()`
 - `impl ShadowVariableSupport for T` — `update_entity_shadows()` (no-op if no shadow config; generates inverse/previous/next/cascading/aggregate/compute updates otherwise)
-- `impl SolvableSolution for T` (when any variable config present) — delegates to `descriptor()` and `entity_count()`
+- `impl SolvableSolution for T` — delegates to `descriptor()` and `entity_count()`
 - `impl Solvable for T` (when constraints path specified) — `solve()` calls `solve_internal()`
 - `impl Analyzable for T` (when constraints path specified) — `analyze()` creates `ScoreDirector` and returns `ScoreAnalysis`
 - `fn solve_internal()` (when constraints path specified) — calls `run_stock_solver()` for macro-generated stock solving (standard-only and list/mixed stock paths); explicit low-level `ProblemSpec` use remains on `run_solver()`
 - `pub trait {Name}ConstraintStreams<Sc>` — accessor methods for all `#[planning_entity_collection]` and `#[problem_fact_collection]` fields; implemented on `ConstraintFactory<{Name}, Sc>`
-- `pub trait {Entity}UnassignedFilter<Sc, E, F>` (when `standard_variable_config` present) — `.unassigned()` method on `UniConstraintStream` filtering entities where the planning variable is `None`
 
 ### `ProblemFactImpl`
 
@@ -133,12 +132,10 @@ Applies to structs. Adds derives: `Clone, Debug, PartialEq, Eq, ProblemFactImpl`
 |----------|-----------|------|
 | `parse_constraints_path` | `fn(&[Attribute]) -> Option<String>` | Extracts `#[solverforge_constraints_path = "..."]` |
 | `parse_shadow_config` | `fn(&[Attribute]) -> ShadowConfig` | Parses `#[shadow_variable_updates(...)]` |
-| `parse_standard_variable_config` | `fn(&[Attribute]) -> StandardVariableConfig` | Parses `#[standard_variable_config(...)]` |
 | `generate_list_operations` | `fn(&ShadowConfig, &Fields, &Option<String>, &Ident) -> TokenStream` | Generates list variable methods + solve_internal |
-| `generate_standard_variable_operations` | `fn(&StandardVariableConfig, &Fields, &Option<String>, &Ident) -> TokenStream` | Generates standard variable methods |
-| `generate_solvable_solution` | `fn(&ShadowConfig, &StandardVariableConfig, &Ident, &Option<String>) -> TokenStream` | Generates SolvableSolution/Solvable/Analyzable impls |
+| `generate_solvable_solution` | `fn(&Ident, &Option<String>) -> TokenStream` | Generates SolvableSolution/Solvable/Analyzable impls |
 | `generate_shadow_support` | `fn(&ShadowConfig, &Ident) -> TokenStream` | Generates ShadowVariableSupport impl |
-| `generate_constraint_stream_extensions` | `fn(&Fields, &StandardVariableConfig, &Ident) -> TokenStream` | Generates `{Name}ConstraintStreams` trait + impl on ConstraintFactory; generates `{Entity}UnassignedFilter` trait if standard_variable_config is present |
+| `generate_constraint_stream_extensions` | `fn(&Fields, &Ident) -> TokenStream` | Generates `{Name}ConstraintStreams` trait + impl on ConstraintFactory |
 | `extract_option_inner_type` | `fn(&Type) -> Result<&Type, Error>` | Extracts `T` from `Option<T>` |
 | `extract_collection_inner_type` | `fn(&Type) -> Option<&Type>` | Extracts `T` from `Vec<T>` |
 
@@ -164,17 +161,6 @@ struct ShadowConfig {
 }
 ```
 
-### `StandardVariableConfig`
-
-```rust
-struct StandardVariableConfig {
-    entity_collection: Option<String>,
-    variable_field: Option<String>,
-    variable_type: Option<String>,
-    value_range: Option<String>,
-}
-```
-
 ## Architectural Notes
 
 ### Code Generation Targets

crates/solverforge-macros/src/lib.rs

@@ -115,7 +115,6 @@ pub fn derive_planning_entity(input: TokenStream) -> TokenStream {
         planning_score,
         value_range_provider,
         shadow_variable_updates,
-        standard_variable_config,
         solverforge_constraints_path
     )
 )]

crates/solverforge-macros/src/planning_entity.rs

@@ -245,6 +245,86 @@ pub fn expand_derive(input: DeriveInput) -> Result<TokenStream, Error> {
         })
         .collect();
 
+    let optional_planning_variables: Vec<_> = planning_variables
+        .iter()
+        .filter_map(|field| {
+            let field_name = field.ident.as_ref()?;
+            field_option_inner_type(&field.ty).map(|field_type| (field_name, field_type))
+        })
+        .collect();
+
+    let unassigned_filter_extension = if optional_planning_variables.len() == 1 {
+        let (field_name, field_type) = optional_planning_variables[0];
+        let predicate_name = syn::Ident::new(
+            &format!(
+                "__{}_{}_unassigned",
+                name.to_string().to_lowercase(),
+                field_name
+            ),
+            proc_macro2::Span::call_site(),
+        );
+        let filter_trait_name = syn::Ident::new(
+            &format!("{}UnassignedFilter", name),
+            proc_macro2::Span::call_site(),
+        );
+
+        quote! {
+            #[allow(non_snake_case)]
+            fn #predicate_name<Solution>(
+                _solution: &Solution,
+                entity: &#name,
+            ) -> bool
+            where
+                Solution: ::solverforge::__internal::PlanningSolution,
+            {
+                let value: &::core::option::Option<#field_type> = &entity.#field_name;
+                value.is_none()
+            }
+
+            pub trait #filter_trait_name<Sc: ::solverforge::Score + 'static, Solution, E, F> {
+                type Output;
+                fn unassigned(self) -> Self::Output;
+            }
+
+            impl<Sc, Solution, E, F> #filter_trait_name<Sc, Solution, E, F>
+                for ::solverforge::__internal::UniConstraintStream<Solution, #name, E, F, Sc>
+            where
+                Sc: ::solverforge::Score + 'static,
+                Solution: ::solverforge::__internal::PlanningSolution,
+                E: Fn(&Solution) -> &[#name] + Send + Sync,
+                F: ::solverforge::__internal::UniFilter<Solution, #name>,
+            {
+                type Output = ::solverforge::__internal::UniConstraintStream<
+                    Solution,
+                    #name,
+                    E,
+                    ::solverforge::__internal::AndUniFilter<
+                        F,
+                        ::solverforge::__internal::FnUniFilter<
+                            fn(&Solution, &#name) -> bool
+                        >,
+                    >,
+                    Sc,
+                >;
+
+                fn unassigned(self) -> Self::Output {
+                    let (extractor, filter) = self.into_parts();
+                    ::solverforge::__internal::UniConstraintStream::from_parts(
+                        extractor,
+                        ::solverforge::__internal::AndUniFilter::new(
+                            filter,
+                            ::solverforge::__internal::FnUniFilter::new(
+                                #predicate_name::<Solution> as fn(&Solution, &#name) -> bool
+                            ),
+                        ),
+                    )
+                }
+            }
+        }
+    } else {
+        TokenStream::new()
+    };
+
     let list_variable_descriptors: Vec<_> = list_variables
         .iter()
         .map(|field| {
@@ -376,33 +456,40 @@ pub fn expand_derive(input: DeriveInput) -> Result<TokenStream, Error> {
                 desc
             }
         }
+
+        #unassigned_filter_extension
     };
 
     Ok(expanded)
 }
 
 fn field_is_option_usize(ty: &syn::Type) -> bool {
+    field_option_inner_type(ty)
+        .and_then(|inner| {
+            let syn::Type::Path(inner_path) = inner else {
+                return None;
+            };
+            inner_path.path.segments.last()
+        })
+        .map(|segment| segment.ident == "usize")
+        .unwrap_or(false)
+}
+
+fn field_option_inner_type(ty: &syn::Type) -> Option<&syn::Type> {
     let syn::Type::Path(type_path) = ty else {
-        return false;
-    };
-    let Some(segment) = type_path.path.segments.last() else {
-        return false;
+        return None;
     };
+    let segment = type_path.path.segments.last()?;
     if segment.ident != "Option" {
-        return false;
+        return None;
     }
     let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
-        return false;
+        return None;
     };
-    let Some(syn::GenericArgument::Type(syn::Type::Path(inner_path))) = args.args.first() else {
-        return false;
+    let Some(syn::GenericArgument::Type(inner)) = args.args.first() else {
+        return None;
     };
-    inner_path
-        .path
-        .segments
-        .last()
-        .map(|segment| segment.ident == "usize")
-        .unwrap_or(false)
+    Some(inner)
 }
 
 #[cfg(test)]
@@ -431,5 +518,7 @@ mod tests {
         assert!(expanded.contains("with_value_range (\"workers\")"));
         assert!(expanded.contains("with_id_field (stringify ! (id))"));
         assert!(expanded.contains("pub fn entity_descriptor"));
+        assert!(expanded.contains("pub trait TaskUnassignedFilter"));
+        assert!(expanded.contains("fn unassigned (self)"));
     }
 }