rename Extra.field to Extra.field_we_are_currently_assigning_to

Author: adriangb

rust-toolchain

@@ -1 +1 @@
-nightly
+nightly-2023-03-01

src/serializers/shared.rs

@@ -74,7 +74,16 @@ impl CombinedSerializer {
         build_context: &mut BuildContext<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         match lookup_type {
-            // TODO: sort alphabetically?
+            // The left hand side of this match is a 1:1 match with the `type` field we use as a discriminator
+            // in our CoreSchema union
+            // The right hand side is _generally_ a 1:1 match but there are cases where we use a `Builder`
+            // on the right that may have internal logic to return different validators or just build a
+            // a more complex validator (e.g. building a union of isinstance validators or something).
+            // So to get from Python -> Rust implementation you should trace the `type` on the left hand side
+            // of the match and then if the right hand side is a `{Type}Validator` you've found the implementation.
+            // If the right hand side is a `{Type}Builder` you'll have to look into it's `build()` method to see
+            // what it actually returns.
+            // TODO: sort alphabetically? By left hand side string or right hand side type? Or RHS type's module filename?
             "any" => super::type_serializers::any::AnySerializer::build(schema, config, build_context),
             "none" => super::type_serializers::simple::NoneSerializer::build(schema, config, build_context),
             "bool" => super::type_serializers::simple::BoolSerializer::build(schema, config, build_context),

src/validators/function.rs

@@ -14,31 +14,11 @@ use crate::recursion_guard::RecursionGuard;
 use super::generator::InternalValidator;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
-pub struct FunctionBuilder;
-
-impl BuildValidator for FunctionBuilder {
-    const EXPECTED_TYPE: &'static str = "function";
-
-    fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
-        build_context: &mut BuildContext<CombinedValidator>,
-    ) -> PyResult<CombinedValidator> {
-        let type_: &str = schema.get_as_req(intern!(schema.py(), "type"))?;
-        match type_ {
-            "function-before" => FunctionBeforeValidator::build(schema, config, build_context),
-            "function-after" => FunctionAfterValidator::build(schema, config, build_context),
-            "function-wrap" => FunctionWrapValidator::build(schema, config, build_context),
-            // must be "plain"
-            _ => FunctionPlainValidator::build(schema, config),
-        }
-    }
-}
-
 macro_rules! impl_build {
     ($impl_name:ident, $name:literal) => {
-        impl $impl_name {
-            pub fn build(
+        impl BuildValidator for $impl_name {
+            const EXPECTED_TYPE: &'static str = $name;
+            fn build(
                 schema: &PyDict,
                 config: Option<&PyDict>,
                 build_context: &mut BuildContext<CombinedValidator>,
@@ -153,8 +133,14 @@ pub struct FunctionPlainValidator {
     name: String,
 }
 
-impl FunctionPlainValidator {
-    pub fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
+impl BuildValidator for FunctionPlainValidator {
+    const EXPECTED_TYPE: &'static str = "function-plain";
+
+    fn build(
+        schema: &PyDict,
+        config: Option<&PyDict>,
+        _build_context: &mut BuildContext<CombinedValidator>,
+    ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let function = schema.get_as_req::<&PyAny>(intern!(py, "function"))?;
         Ok(Self {

src/validators/mod.rs

@@ -348,6 +348,16 @@ pub fn build_validator<'a>(
     let schema: &PyDict = schema.downcast()?;
     let type_: &str = schema.get_as_req(intern!(schema.py(), "type"))?;
     let val = match type_ {
+        // The left hand side of this match is a 1:1 match with the `type` field we use as a discriminator
+        // in our CoreSchema union
+        // The right hand side is _generally_ a 1:1 match but there are cases where we use a `Builder`
+        // on the right that may have internal logic to return different validators or just build a
+        // a more complex validator (e.g. building a union of isinstance validators or something).
+        // So to get from Python -> Rust implementation you should trace the `type` on the left hand side
+        // of the match and then if the right hand side is a `{Type}Validator` you've found the implementation.
+        // If the right hand side is a `{Type}Builder` you'll have to look into it's `build()` method to see
+        // what it actually returns.
+        // TODO: sort alphabetically? By left hand side string or right hand side type? Or RHS type's module filename?
         "any" => build_specific_validator::<any::AnyValidator>(schema, type_, config, build_context)?,
         "none" => build_specific_validator::<none::NoneValidator>(schema, type_, config, build_context)?,
         "bool" => build_specific_validator::<bool::BoolValidator>(schema, type_, config, build_context)?,
@@ -379,15 +389,17 @@ pub fn build_validator<'a>(
         "generator" => build_specific_validator::<generator::GeneratorValidator>(schema, type_, config, build_context)?,
         "dict" => build_specific_validator::<dict::DictValidator>(schema, type_, config, build_context)?,
         "function-plain" => {
-            build_specific_validator::<function::FunctionBuilder>(schema, type_, config, build_context)?
+            build_specific_validator::<function::FunctionPlainValidator>(schema, type_, config, build_context)?
         }
         "function-before" => {
-            build_specific_validator::<function::FunctionBuilder>(schema, type_, config, build_context)?
+            build_specific_validator::<function::FunctionBeforeValidator>(schema, type_, config, build_context)?
         }
         "function-after" => {
-            build_specific_validator::<function::FunctionBuilder>(schema, type_, config, build_context)?
+            build_specific_validator::<function::FunctionAfterValidator>(schema, type_, config, build_context)?
+        }
+        "function-wrap" => {
+            build_specific_validator::<function::FunctionWrapValidator>(schema, type_, config, build_context)?
         }
-        "function-wrap" => build_specific_validator::<function::FunctionBuilder>(schema, type_, config, build_context)?,
         "default" => {
             build_specific_validator::<with_default::WithDefaultValidator>(schema, type_, config, build_context)?
         }