Session 11: Code Quality - Unused Self Arguments - Major Progress

Fixed major unused self argument issues by properly converting methods to associated functions:
- Fixed core.rs: generate_field method converted to associated function
- Fixed fields.rs: get_rust_type and get_default_value methods converted to associated functions
- Fixed validation.rs: generate_pattern_check and generate_range_validation methods converted to associated functions
- Fixed implementations.rs: generate_class_tests method converted to associated function
- Fixed all call sites in builders.rs, classes.rs, and rust_traits.rs to use Self:: syntax
- Converted 6+ methods that don't use self state to associated functions

Core library compiles cleanly
Current clippy warnings in core lib: 774 (with 209 unused self warnings remaining)

Author: simonckemper

linkml-service/src/generator/builders.rs

@@ -36,7 +36,7 @@ impl RustGenerator {
         for slot_name in &all_slots {
             if let Some(slot) = schema.slots.get(slot_name) {
                 let field_name = Self::convert_field_name(slot_name);
-                let field_type = self.get_rust_type(slot, schema);
+                let field_type = Self::get_rust_type(slot, schema);
 
                 writeln!(
                     output,
@@ -115,7 +115,7 @@ impl RustGenerator {
         indent: &IndentStyle,
     ) -> GeneratorResult<()> {
         let field_name = Self::convert_field_name(slot_name);
-        let field_type = self.get_rust_type(slot, schema);
+        let field_type = Self::get_rust_type(slot, schema);
 
         // Documentation
         if options.include_docs {

linkml-service/src/generator/classes.rs

@@ -160,7 +160,7 @@ impl RustGenerator {
         for slot_name in &all_slots {
             if let Some(slot) = schema.slots.get(slot_name) {
                 let field_name = Self::convert_field_name(slot_name);
-                let default_value = self.get_default_value(slot, schema);
+                let default_value = Self::get_default_value(slot, schema);
 
                 writeln!(
                     output,

linkml-service/src/generator/core.rs

@@ -152,7 +152,7 @@ impl RustGenerator {
             // Generate fields for each slot
             for slot_name in &slots {
                 if let Some(slot_def) = schema.slots.get(slot_name) {
-                    self.generate_field(&mut output, slot_name, slot_def, schema)?;
+                    Self::generate_field(&mut output, slot_name, slot_def, schema)?;
                 }
             }
         }
@@ -162,7 +162,7 @@ impl RustGenerator {
     }
 
     /// Generate a field from a slot definition
-    pub(super) fn generate_field(&self, output: &mut String, slot_name: &str, slot_def: &SlotDefinition, schema: &SchemaDefinition) -> GeneratorResult<()> {
+    pub(super) fn generate_field(output: &mut String, slot_name: &str, slot_def: &SlotDefinition, schema: &SchemaDefinition) -> GeneratorResult<()> {
         // Add field documentation
         if let Some(ref desc) = slot_def.description {
             writeln!(output, "    /// {desc}").map_err(Self::fmt_error_to_generator_error)?;

linkml-service/src/generator/fields.rs

@@ -48,7 +48,7 @@ impl RustGenerator {
                 }
 
                 // Field definition
-                let field_type = self.get_rust_type(slot, schema);
+                let field_type = Self::get_rust_type(slot, schema);
                 writeln!(
                     output,
                     "{}pub {}: {},",
@@ -65,7 +65,6 @@ impl RustGenerator {
 
     /// Get Rust type for a slot
     pub(super) fn get_rust_type(
-        &self,
         slot: &SlotDefinition,
         schema: &SchemaDefinition,
     ) -> String {
@@ -116,7 +115,6 @@ impl RustGenerator {
 
     /// Get default value for a field
     pub(super) fn get_default_value(
-        &self,
         slot: &SlotDefinition,
         schema: &SchemaDefinition,
     ) -> String {

linkml-service/src/generator/implementations.rs

@@ -146,7 +146,7 @@ impl RustGenerator {
 
         // Generate tests for each class
         for (class_name, class) in &schema.classes {
-            self.generate_class_tests(&mut output, class_name, class, schema, options)?;
+            Self::generate_class_tests(&mut output, class_name, class, schema, options)?;
         }
 
         writeln!(&mut output, "}}")
@@ -176,7 +176,6 @@ impl RustGenerator {
 
     /// Generate tests for a specific class
     fn generate_class_tests(
-        &self,
         output: &mut String,
         class_name: &str,
         _class: &ClassDefinition,

linkml-service/src/generator/rust_traits.rs

@@ -69,7 +69,7 @@ impl RustGenerator {
             if let Some(slot) = schema.slots.get(slot_name)
                 && (slot.identifier == Some(true) || slot.required == Some(true)) {
                     let field_name = BaseCodeFormatter::to_snake_case(slot_name);
-                    let return_type = self.get_rust_type(slot, schema);
+                    let return_type = Self::get_rust_type(slot, schema);
                     writeln!(&mut output).map_err(Self::fmt_error_to_generator_error)?;
                     writeln!(&mut output, "    /// Get the {field_name} field")
                         .map_err(Self::fmt_error_to_generator_error)?;

linkml-service/src/generator/validation.rs

@@ -148,12 +148,12 @@ impl RustGenerator {
                     field_name
                 )
                 .map_err(Self::fmt_error_to_generator_error)?;
-                self.generate_pattern_check(output, slot_name, pattern, "item", indent.to_string(3))?;
+                Self::generate_pattern_check(output, slot_name, pattern, "item", indent.to_string(3))?;
                 writeln!(output, "{}}}", indent.to_string(2))
                     .map_err(Self::fmt_error_to_generator_error)?;
             } else if slot.required.unwrap_or(false) {
                 // Validate required field directly
-                self.generate_pattern_check(output, slot_name, pattern, &format!("&self.{field_name}"), indent.to_string(2))?;
+                Self::generate_pattern_check(output, slot_name, pattern, &format!("&self.{field_name}"), indent.to_string(2))?;
             } else {
                 // Validate optional field if present
                 writeln!(
@@ -163,7 +163,7 @@ impl RustGenerator {
                     field_name
                 )
                 .map_err(Self::fmt_error_to_generator_error)?;
-                self.generate_pattern_check(output, slot_name, pattern, "value", indent.to_string(3))?;
+                Self::generate_pattern_check(output, slot_name, pattern, "value", indent.to_string(3))?;
                 writeln!(output, "{}}}", indent.to_string(2))
                     .map_err(Self::fmt_error_to_generator_error)?;
             }
@@ -173,7 +173,7 @@ impl RustGenerator {
         if let Some(range) = &slot.range
             && matches!(range.as_str(), "integer" | "int" | "float" | "double")
                 && let (Some(min_val), Some(max_val)) = (&slot.minimum_value, &slot.maximum_value) {
-                    self.generate_range_validation(output, slot_name, &field_name, min_val, max_val, slot, indent)?;
+                    Self::generate_range_validation(output, slot_name, &field_name, min_val, max_val, slot, indent)?;
                 }
 
         writeln!(output).map_err(Self::fmt_error_to_generator_error)?;
@@ -182,7 +182,6 @@ impl RustGenerator {
 
     /// Generate pattern validation check
     fn generate_pattern_check(
-        &self,
         output: &mut String,
         slot_name: &str,
         pattern: &str,
@@ -222,7 +221,6 @@ impl RustGenerator {
     /// Generate range validation for numeric fields
     #[allow(clippy::too_many_arguments)]
     fn generate_range_validation(
-        &self,
         output: &mut String,
         slot_name: &str,
         field_name: &str,