perf: Only check defaults once

Author: tobni

src/rust/engine/src/externs/target/field.rs

@@ -2,7 +2,11 @@
 // Licensed under the Apache License, Version 2.0 (see LICENSE).
 
 use std::fmt::Write;
+use std::sync::OnceLock;
 
+use fnv::FnvHashMap;
+
+use parking_lot::Mutex;
 use pyo3::basic::CompareOp;
 use pyo3::exceptions::PyValueError;
 use pyo3::intern;
@@ -11,11 +15,54 @@ use pyo3::pybacked::PyBackedStr;
 use pyo3::pyclass_init::PyClassInitializer;
 use pyo3::types::PyType;
 
+use crate::TypeId;
 use crate::externs::address::Address;
 use crate::python::PyComparedBool;
 
 use super::util::{NoFieldValue, combine_hashes, raise_invalid_field_type, validate_choices};
 
+static FIELD_TYPE_INFO_CACHE: OnceLock<Mutex<FnvHashMap<TypeId, FieldTypeInfo>>> = OnceLock::new();
+
+struct FieldTypeInfo {
+    none_is_valid_value: bool,
+    deprecated: bool,
+    /// None means required (no default). Some holds the default value.
+    default: Option<Py<PyAny>>,
+}
+
+impl FieldTypeInfo {
+    fn resolve(cls: &Bound<'_, PyType>, py: Python) -> PyResult<Self> {
+        let removal_version: Option<PyBackedStr> =
+            cls.getattr(intern!(py, "removal_version"))?.extract()?;
+        let required: bool = cls.getattr(intern!(py, "required"))?.extract()?;
+        let default = if required {
+            None
+        } else {
+            Some(cls.getattr(intern!(py, "default"))?.unbind())
+        };
+        Ok(Self {
+            none_is_valid_value: cls.getattr(intern!(py, "none_is_valid_value"))?.extract()?,
+            deprecated: removal_version.is_some(),
+            default,
+        })
+    }
+}
+
+fn with_field_type_info<R>(
+    cls: &Bound<'_, PyType>,
+    py: Python,
+    f: impl FnOnce(&FieldTypeInfo) -> R,
+) -> PyResult<R> {
+    let type_id = TypeId::new(cls);
+    let cache = FIELD_TYPE_INFO_CACHE.get_or_init(|| Mutex::new(FnvHashMap::default()));
+    let mut locked = cache.lock();
+    let info = match locked.entry(type_id) {
+        std::collections::hash_map::Entry::Occupied(e) => e.into_mut(),
+        std::collections::hash_map::Entry::Vacant(e) => e.insert(FieldTypeInfo::resolve(cls, py)?),
+    };
+    Ok(f(info))
+}
+
 #[pyclass(subclass, frozen, module = "pants.engine.internals.native_engine")]
 pub struct Field {
     pub(crate) value: Py<PyAny>,
@@ -37,13 +84,9 @@ impl Field {
         //  to None below.
         Self::check_deprecated(cls, raw_value, &address, py)?;
 
+        let none_is_valid = with_field_type_info(cls, py, |info| info.none_is_valid_value)?;
         let raw_value = match raw_value {
-            Some(value)
-                if value.extract::<NoFieldValue>().is_ok()
-                    && !Self::cls_none_is_valid_value(cls)? =>
-            {
-                None
-            }
+            Some(value) if value.extract::<NoFieldValue>().is_ok() && !none_is_valid => None,
             rv => rv,
         };
 
@@ -97,28 +140,29 @@ impl Field {
         address: PyRef<Address>,
         py: Python<'py>,
     ) -> PyResult<Bound<'py, PyAny>> {
-        let default = || -> PyResult<Bound<'_, PyAny>> {
-            if Self::cls_required(cls)? {
-                // TODO: Should be `RequiredFieldMissingException`.
-                Err(PyValueError::new_err(format!(
-                    "The `{}` field in target {} must be defined.",
-                    Self::cls_alias(cls)?,
-                    *address,
-                )))
-            } else {
-                Self::cls_default(cls)
+        with_field_type_info(cls, py, |info| {
+            let default = || -> PyResult<Bound<'_, PyAny>> {
+                match &info.default {
+                    Some(d) => Ok(d.bind(py).clone()),
+                    None => Err(PyValueError::new_err(format!(
+                        "The `{}` field in target {} must be defined.",
+                        Self::cls_alias(cls)?,
+                        *address,
+                    ))),
+                }
+            };
+
+            match raw_value {
+                Some(value)
+                    if info.none_is_valid_value && value.extract::<NoFieldValue>().is_ok() =>
+                {
+                    default()
+                }
+                None if info.none_is_valid_value => Ok(py.None().into_bound(py)),
+                None => default(),
+                Some(value) => Ok(value.clone()),
             }
-        };
-
-        let none_is_valid_value = Self::cls_none_is_valid_value(cls)?;
-        match raw_value {
-            Some(value) if none_is_valid_value && value.extract::<NoFieldValue>().is_ok() => {
-                default()
-            }
-            None if none_is_valid_value => Ok(py.None().into_bound(py)),
-            None => default(),
-            Some(value) => Ok(value.clone()),
-        }
+        })?
     }
 
     #[getter]
@@ -227,6 +271,10 @@ impl Field {
         address: &Bound<'_, Address>,
         py: Python,
     ) -> PyResult<()> {
+        let is_deprecated = with_field_type_info(cls, py, |info| info.deprecated)?;
+        if !is_deprecated {
+            return Ok(());
+        }
         if address.borrow().is_generated_target() {
             return Ok(());
         }