Cleanup: use '_num' suffix, mostly for curves & spline code

Replace tot/amount & size with num, in keeping with T85728.

74 files changed, 575 insertions, 582 deletions

diff --git a/source/blender/blenkernel/BKE_curves.hh b/source/blender/blenkernel/BKE_curves.hh
index 3e57041dec3..87fa26a4f73 100644
--- a/source/blender/blenkernel/BKE_curves.hh
+++ b/source/blender/blenkernel/BKE_curves.hh
@@ -50,7 +50,7 @@ struct BasisCache {
   Vector<int> start_indices;
 
   /**
-   * The result of #check_valid_size_and_order, to avoid retrieving its inputs later on.
+   * The result of #check_valid_num_and_order, to avoid retrieving its inputs later on.
    * If this is true, the data above will be invalid, and original data should be copied
    * to the evaluated result.
    */
@@ -418,7 +418,7 @@ namespace curves {
  * The number of segments between control points, accounting for the last segment of cyclic
  * curves. The logic is simple, but this function should be used to make intentions clearer.
  */
-inline int curve_segment_size(const int points_num, const bool cyclic)
+inline int curve_segment_num(const int points_num, const bool cyclic)
 {
   BLI_assert(points_num > 0);
   return (cyclic && points_num > 1) ? points_num : points_num - 1;
@@ -585,11 +585,11 @@ namespace catmull_rom {
  * \param points_num: The number of points in the curve.
  * \param resolution: The resolution for each segment.
  */
-int calculate_evaluated_size(int points_num, bool cyclic, int resolution);
+int calculate_evaluated_num(int points_num, bool cyclic, int resolution);
 
 /**
  * Evaluate the Catmull Rom curve. The length of the #dst span should be calculated with
- * #calculate_evaluated_size and is expected to divide evenly by the #src span's segment size.
+ * #calculate_evaluated_num and is expected to divide evenly by the #src span's segment size.
  */
 void interpolate_to_evaluated(GSpan src, bool cyclic, int resolution, GMutableSpan dst);
 
@@ -606,7 +606,7 @@ namespace nurbs {
 /**
  * Checks the conditions that a NURBS curve needs to evaluate.
  */
-bool check_valid_size_and_order(int points_num, int8_t order, bool cyclic, KnotsMode knots_mode);
+bool check_valid_num_and_order(int points_num, int8_t order, bool cyclic, KnotsMode knots_mode);
 
 /**
  * Calculate the standard evaluated size for a NURBS curve, using the standard that
@@ -616,7 +616,7 @@ bool check_valid_size_and_order(int points_num, int8_t order, bool cyclic, Knots
  * for predictability and so that cached basis weights of NURBS curves with these properties can be
  * shared.
  */
-int calculate_evaluated_size(
+int calculate_evaluated_num(
     int points_num, int8_t order, bool cyclic, int resolution, KnotsMode knots_mode);
 
 /**
@@ -624,7 +624,7 @@ int calculate_evaluated_size(
  * The knots must be longer for a cyclic curve, for example, in order to provide weights for the
  * last evaluated points that are also influenced by the first control points.
  */
-int knots_size(int points_num, int8_t order, bool cyclic);
+int knots_num(int points_num, int8_t order, bool cyclic);
 
 /**
  * Calculate the knots for a curve given its properties, based on built-in standards defined by
@@ -644,7 +644,7 @@ void calculate_knots(
  * and a weight for each control point.
  */
 void calculate_basis_cache(int points_num,
-                           int evaluated_size,
+                           int evaluated_num,
                            int8_t order,
                            bool cyclic,
                            Span<float> knots,
@@ -770,7 +770,7 @@ inline IndexRange CurvesGeometry::lengths_range_for_curve(const int curve_index,
   BLI_assert(cyclic == this->cyclic()[curve_index]);
   const IndexRange points = this->evaluated_points_for_curve(curve_index);
   const int start = points.start() + curve_index;
-  return {start, curves::curve_segment_size(points.size(), cyclic)};
+  return {start, curves::curve_segment_num(points.size(), cyclic)};
 }
 
 inline Span<float> CurvesGeometry::evaluated_lengths_for_curve(const int curve_index,
diff --git a/source/blender/blenkernel/BKE_geometry_set.hh b/source/blender/blenkernel/BKE_geometry_set.hh
index dfd9fccebbd..849c430fd7b 100644
--- a/source/blender/blenkernel/BKE_geometry_set.hh
+++ b/source/blender/blenkernel/BKE_geometry_set.hh
@@ -98,7 +98,7 @@ class GeometryComponent {
   /**
    * Return the length of a specific domain, or 0 if the domain is not supported.
    */
-  virtual int attribute_domain_size(AttributeDomain domain) const;
+  virtual int attribute_domain_num(AttributeDomain domain) const;
 
   /**
    * Return true if the attribute name corresponds to a built-in attribute with a hardcoded domain
@@ -560,7 +560,7 @@ class MeshComponent : public GeometryComponent {
    */
   Mesh *get_for_write();
 
-  int attribute_domain_size(AttributeDomain domain) const final;
+  int attribute_domain_num(AttributeDomain domain) const final;
 
   bool is_empty() const final;
 
@@ -623,7 +623,7 @@ class PointCloudComponent : public GeometryComponent {
    */
   PointCloud *get_for_write();
 
-  int attribute_domain_size(AttributeDomain domain) const final;
+  int attribute_domain_num(AttributeDomain domain) const final;
 
   bool is_empty() const final;
 
@@ -664,7 +664,7 @@ class CurveComponentLegacy : public GeometryComponent {
   const CurveEval *get_for_read() const;
   CurveEval *get_for_write();
 
-  int attribute_domain_size(AttributeDomain domain) const final;
+  int attribute_domain_num(AttributeDomain domain) const final;
 
   bool is_empty() const final;
 
@@ -715,7 +715,7 @@ class CurveComponent : public GeometryComponent {
   const Curves *get_for_read() const;
   Curves *get_for_write();
 
-  int attribute_domain_size(AttributeDomain domain) const final;
+  int attribute_domain_num(AttributeDomain domain) const final;
 
   bool is_empty() const final;
 
@@ -949,8 +949,8 @@ class InstancesComponent : public GeometryComponent {
   blender::MutableSpan<blender::float4x4> instance_transforms();
   blender::Span<blender::float4x4> instance_transforms() const;
 
-  int instances_amount() const;
-  int references_amount() const;
+  int instances_num() const;
+  int references_num() const;
 
   /**
    * Remove the indices that are not contained in the mask input, and remove unused instance
@@ -963,7 +963,7 @@ class InstancesComponent : public GeometryComponent {
   blender::bke::CustomDataAttributes &attributes();
   const blender::bke::CustomDataAttributes &attributes() const;
 
-  int attribute_domain_size(AttributeDomain domain) const final;
+  int attribute_domain_num(AttributeDomain domain) const final;
 
   void foreach_referenced_geometry(
       blender::FunctionRef<void(const GeometrySet &geometry_set)> callback) const;
diff --git a/source/blender/blenkernel/BKE_spline.hh b/source/blender/blenkernel/BKE_spline.hh
index 6cbb47dc709..28f326a4ad4 100644
--- a/source/blender/blenkernel/BKE_spline.hh
+++ b/source/blender/blenkernel/BKE_spline.hh
@@ -102,7 +102,7 @@ class Spline {
 
   /** Return the number of control points. */
   virtual int size() const = 0;
-  int segments_size() const;
+  int segments_num() const;
   bool is_cyclic() const;
   void set_cyclic(bool value);
 
@@ -127,8 +127,8 @@ class Spline {
    * change the generated positions, tangents, normals, mapping, etc. of the evaluated points.
    */
   virtual void mark_cache_invalid() = 0;
-  virtual int evaluated_points_size() const = 0;
-  int evaluated_edges_size() const;
+  virtual int evaluated_points_num() const = 0;
+  int evaluated_edges_num() const;
 
   float length() const;
 
@@ -164,7 +164,7 @@ class Spline {
     /**
      * The index of the evaluated point after the result location, accounting for wrapping when
      * the spline is cyclic. If the sampled factor/length is the very end of the spline, this will
-     * be the last index (#evaluated_points_size - 1).
+     * be the last index (#evaluated_points_num - 1).
      */
     int next_evaluated_index;
     /**
@@ -191,7 +191,7 @@ class Spline {
    * indices and factors to the next index encoded in floats. The logic for converting from the
    * float values to interpolation data is in #lookup_data_from_index_factor.
    */
-  blender::Array<float> sample_uniform_index_factors(int samples_size) const;
+  blender::Array<float> sample_uniform_index_factors(int samples_num) const;
   LookupResult lookup_data_from_index_factor(float index_factor) const;
 
   /**
@@ -344,7 +344,7 @@ class BezierSpline final : public Spline {
   bool point_is_sharp(int index) const;
 
   void mark_cache_invalid() final;
-  int evaluated_points_size() const final;
+  int evaluated_points_num() const final;
 
   /**
    * Returns access to a cache of offsets into the evaluated point array for each control point.
@@ -472,7 +472,7 @@ class NURBSpline final : public Spline {
 
   /**
    * Determines where and how the control points affect the evaluated points. The length should
-   * always be the value returned by #knots_size(), and each value should be greater than or equal
+   * always be the value returned by #knots_num(), and each value should be greater than or equal
    * to the previous. Only invalidated when a point is added or removed.
    */
   mutable blender::Vector<float> knots_;
@@ -514,8 +514,8 @@ class NURBSpline final : public Spline {
   uint8_t order() const;
   void set_order(uint8_t value);
 
-  bool check_valid_size_and_order() const;
-  int knots_size() const;
+  bool check_valid_num_and_order() const;
+  int knots_num() const;
 
   void resize(int size) final;
   blender::MutableSpan<blender::float3> positions() final;
@@ -530,7 +530,7 @@ class NURBSpline final : public Spline {
   blender::Span<float> weights() const;
 
   void mark_cache_invalid() final;
-  int evaluated_points_size() const final;
+  int evaluated_points_num() const final;
 
   blender::Span<blender::float3> evaluated_positions() const final;
 
@@ -582,7 +582,7 @@ class PolySpline final : public Spline {
   blender::Span<float> tilts() const final;
 
   void mark_cache_invalid() final;
-  int evaluated_points_size() const final;
+  int evaluated_points_num() const final;
 
   blender::Span<blender::float3> evaluated_positions() const final;
 
@@ -665,7 +665,7 @@ struct CurveEval {
   blender::Array<float> accumulated_spline_lengths() const;
 
   float total_length() const;
-  int total_control_point_size() const;
+  int total_control_point_num() const;
 
   void mark_cache_invalid();
 
diff --git a/source/blender/blenkernel/intern/attribute_access.cc b/source/blender/blenkernel/intern/attribute_access.cc
index d33b64c493b..e86bac21084 100644
--- a/source/blender/blenkernel/intern/attribute_access.cc
+++ b/source/blender/blenkernel/intern/attribute_access.cc
@@ -184,16 +184,16 @@ static AttributeIDRef attribute_id_from_custom_data_layer(const CustomDataLayer
 
 static bool add_builtin_type_custom_data_layer_from_init(CustomData &custom_data,
                                                          const CustomDataType data_type,
-                                                         const int domain_size,
+                                                         const int domain_num,
                                                          const AttributeInit &initializer)
 {
   switch (initializer.type) {
     case AttributeInit::Type::Default: {
-      void *data = CustomData_add_layer(&custom_data, data_type, CD_DEFAULT, nullptr, domain_size);
+      void *data = CustomData_add_layer(&custom_data, data_type, CD_DEFAULT, nullptr, domain_num);
       return data != nullptr;
     }
     case AttributeInit::Type::VArray: {
-      void *data = CustomData_add_layer(&custom_data, data_type, CD_DEFAULT, nullptr, domain_size);
+      void *data = CustomData_add_layer(&custom_data, data_type, CD_DEFAULT, nullptr, domain_num);
       if (data == nullptr) {
         return false;
       }
@@ -204,7 +204,7 @@ static bool add_builtin_type_custom_data_layer_from_init(CustomData &custom_data
     case AttributeInit::Type::MoveArray: {
       void *source_data = static_cast<const AttributeInitMove &>(initializer).data;
       void *data = CustomData_add_layer(
-          &custom_data, data_type, CD_ASSIGN, source_data, domain_size);
+          &custom_data, data_type, CD_ASSIGN, source_data, domain_num);
       if (data == nullptr) {
         MEM_freeN(source_data);
         return false;
@@ -221,35 +221,35 @@ static void *add_generic_custom_data_layer(CustomData &custom_data,
                                            const CustomDataType data_type,
                                            const eCDAllocType alloctype,
                                            void *layer_data,
-                                           const int domain_size,
+                                           const int domain_num,
                                            const AttributeIDRef &attribute_id)
 {
   if (attribute_id.is_named()) {
     char attribute_name_c[MAX_NAME];
     attribute_id.name().copy(attribute_name_c);
     return CustomData_add_layer_named(
-        &custom_data, data_type, alloctype, layer_data, domain_size, attribute_name_c);
+        &custom_data, data_type, alloctype, layer_data, domain_num, attribute_name_c);
   }
   const AnonymousAttributeID &anonymous_id = attribute_id.anonymous_id();
   return CustomData_add_layer_anonymous(
-      &custom_data, data_type, alloctype, layer_data, domain_size, &anonymous_id);
+      &custom_data, data_type, alloctype, layer_data, domain_num, &anonymous_id);
 }
 
 static bool add_custom_data_layer_from_attribute_init(const AttributeIDRef &attribute_id,
                                                       CustomData &custom_data,
                                                       const CustomDataType data_type,
-                                                      const int domain_size,
+                                                      const int domain_num,
                                                       const AttributeInit &initializer)
 {
   switch (initializer.type) {
     case AttributeInit::Type::Default: {
       void *data = add_generic_custom_data_layer(
-          custom_data, data_type, CD_DEFAULT, nullptr, domain_size, attribute_id);
+          custom_data, data_type, CD_DEFAULT, nullptr, domain_num, attribute_id);
       return data != nullptr;
     }
     case AttributeInit::Type::VArray: {
       void *data = add_generic_custom_data_layer(
-          custom_data, data_type, CD_DEFAULT, nullptr, domain_size, attribute_id);
+          custom_data, data_type, CD_DEFAULT, nullptr, domain_num, attribute_id);
       if (data == nullptr) {
         return false;
       }
@@ -260,7 +260,7 @@ static bool add_custom_data_layer_from_attribute_init(const AttributeIDRef &attr
     case AttributeInit::Type::MoveArray: {
       void *source_data = static_cast<const AttributeInitMove &>(initializer).data;
       void *data = add_generic_custom_data_layer(
-          custom_data, data_type, CD_ASSIGN, source_data, domain_size, attribute_id);
+          custom_data, data_type, CD_ASSIGN, source_data, domain_num, attribute_id);
       if (data == nullptr) {
         MEM_freeN(source_data);
         return false;
@@ -303,8 +303,8 @@ GVArray BuiltinCustomDataLayerProvider::try_get_for_read(const GeometryComponent
     return {};
   }
 
-  const int domain_size = component.attribute_domain_size(domain_);
-  return as_read_attribute_(data, domain_size);
+  const int domain_num = component.attribute_domain_num(domain_);
+  return as_read_attribute_(data, domain_num);
 }
 
 WriteAttributeLookup BuiltinCustomDataLayerProvider::try_get_for_write(
@@ -317,7 +317,7 @@ WriteAttributeLookup BuiltinCustomDataLayerProvider::try_get_for_write(
   if (custom_data == nullptr) {
     return {};
   }
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
 
   void *data;
   if (stored_as_named_attribute_) {
@@ -333,10 +333,10 @@ WriteAttributeLookup BuiltinCustomDataLayerProvider::try_get_for_write(
   void *new_data;
   if (stored_as_named_attribute_) {
     new_data = CustomData_duplicate_referenced_layer_named(
-        custom_data, stored_type_, name_.c_str(), domain_size);
+        custom_data, stored_type_, name_.c_str(), domain_num);
   }
   else {
-    new_data = CustomData_duplicate_referenced_layer(custom_data, stored_type_, domain_size);
+    new_data = CustomData_duplicate_referenced_layer(custom_data, stored_type_, domain_num);
   }
 
   if (data != new_data) {
@@ -353,7 +353,7 @@ WriteAttributeLookup BuiltinCustomDataLayerProvider::try_get_for_write(
     };
   }
 
-  return {as_write_attribute_(data, domain_size), domain_, std::move(tag_modified_fn)};
+  return {as_write_attribute_(data, domain_num), domain_, std::move(tag_modified_fn)};
 }
 
 bool BuiltinCustomDataLayerProvider::try_delete(GeometryComponent &component) const
@@ -366,7 +366,7 @@ bool BuiltinCustomDataLayerProvider::try_delete(GeometryComponent &component) co
     return {};
   }
 
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   int layer_index;
   if (stored_as_named_attribute_) {
     for (const int i : IndexRange(custom_data->totlayer)) {
@@ -381,7 +381,7 @@ bool BuiltinCustomDataLayerProvider::try_delete(GeometryComponent &component) co
   }
 
   const bool delete_success = CustomData_free_layer(
-      custom_data, stored_type_, domain_size, layer_index);
+      custom_data, stored_type_, domain_num, layer_index);
   if (delete_success) {
     if (custom_data_access_.update_custom_data_pointers) {
       custom_data_access_.update_custom_data_pointers(component);
@@ -401,7 +401,7 @@ bool BuiltinCustomDataLayerProvider::try_create(GeometryComponent &component,
     return false;
   }
 
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   bool success;
   if (stored_as_named_attribute_) {
     if (CustomData_get_layer_named(custom_data, data_type_, name_.c_str())) {
@@ -409,7 +409,7 @@ bool BuiltinCustomDataLayerProvider::try_create(GeometryComponent &component,
       return false;
     }
     success = add_custom_data_layer_from_attribute_init(
-        name_, *custom_data, stored_type_, domain_size, initializer);
+        name_, *custom_data, stored_type_, domain_num, initializer);
   }
   else {
     if (CustomData_get_layer(custom_data, stored_type_) != nullptr) {
@@ -417,7 +417,7 @@ bool BuiltinCustomDataLayerProvider::try_create(GeometryComponent &component,
       return false;
     }
     success = add_builtin_type_custom_data_layer_from_init(
-        *custom_data, stored_type_, domain_size, initializer);
+        *custom_data, stored_type_, domain_num, initializer);
   }
   if (success) {
     if (custom_data_access_.update_custom_data_pointers) {
@@ -446,7 +446,7 @@ ReadAttributeLookup CustomDataAttributeProvider::try_get_for_read(
   if (custom_data == nullptr) {
     return {};
   }
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   for (const CustomDataLayer &layer : Span(custom_data->layers, custom_data->totlayer)) {
     if (!custom_data_layer_matches_attribute_id(layer, attribute_id)) {
       continue;
@@ -455,7 +455,7 @@ ReadAttributeLookup CustomDataAttributeProvider::try_get_for_read(
     if (type == nullptr) {
       continue;
     }
-    GSpan data{*type, layer.data, domain_size};
+    GSpan data{*type, layer.data, domain_num};
     return {GVArray::ForSpan(data), domain_};
   }
   return {};
@@ -468,24 +468,23 @@ WriteAttributeLookup CustomDataAttributeProvider::try_get_for_write(
   if (custom_data == nullptr) {
     return {};
   }
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   for (CustomDataLayer &layer : MutableSpan(custom_data->layers, custom_data->totlayer)) {
     if (!custom_data_layer_matches_attribute_id(layer, attribute_id)) {
       continue;
     }
     if (attribute_id.is_named()) {
-      CustomData_duplicate_referenced_layer_named(
-          custom_data, layer.type, layer.name, domain_size);
+      CustomData_duplicate_referenced_layer_named(custom_data, layer.type, layer.name, domain_num);
     }
     else {
       CustomData_duplicate_referenced_layer_anonymous(
-          custom_data, layer.type, &attribute_id.anonymous_id(), domain_size);
+          custom_data, layer.type, &attribute_id.anonymous_id(), domain_num);
     }
     const CPPType *type = custom_data_type_to_cpp_type((CustomDataType)layer.type);
     if (type == nullptr) {
       continue;
     }
-    GMutableSpan data{*type, layer.data, domain_size};
+    GMutableSpan data{*type, layer.data, domain_num};
     return {GVMutableArray::ForSpan(data), domain_};
   }
   return {};
@@ -498,12 +497,12 @@ bool CustomDataAttributeProvider::try_delete(GeometryComponent &component,
   if (custom_data == nullptr) {
     return false;
   }
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   for (const int i : IndexRange(custom_data->totlayer)) {
     const CustomDataLayer &layer = custom_data->layers[i];
     if (this->type_is_supported((CustomDataType)layer.type) &&
         custom_data_layer_matches_attribute_id(layer, attribute_id)) {
-      CustomData_free_layer(custom_data, layer.type, domain_size, i);
+      CustomData_free_layer(custom_data, layer.type, domain_num, i);
       return true;
     }
   }
@@ -531,9 +530,9 @@ bool CustomDataAttributeProvider::try_create(GeometryComponent &component,
       return false;
     }
   }
-  const int domain_size = component.attribute_domain_size(domain_);
+  const int domain_num = component.attribute_domain_num(domain_);
   add_custom_data_layer_from_attribute_init(
-      attribute_id, *custom_data, data_type, domain_size, initializer);
+      attribute_id, *custom_data, data_type, domain_num, initializer);
   return true;
 }
 
@@ -567,8 +566,8 @@ ReadAttributeLookup NamedLegacyCustomDataProvider::try_get_for_read(
   for (const CustomDataLayer &layer : Span(custom_data->layers, custom_data->totlayer)) {
     if (layer.type == stored_type_) {
       if (custom_data_layer_matches_attribute_id(layer, attribute_id)) {
-        const int domain_size = component.attribute_domain_size(domain_);
-        return {as_read_attribute_(layer.data, domain_size), domain_};
+        const int domain_num = component.attribute_domain_num(domain_);
+        return {as_read_attribute_(layer.data, domain_num), domain_};
       }
     }
   }
@@ -585,16 +584,16 @@ WriteAttributeLookup NamedLegacyCustomDataProvider::try_get_for_write(
   for (CustomDataLayer &layer : MutableSpan(custom_data->layers, custom_data->totlayer)) {
     if (layer.type == stored_type_) {
       if (custom_data_layer_matches_attribute_id(layer, attribute_id)) {
-        const int domain_size = component.attribute_domain_size(domain_);
+        const int domain_num = component.attribute_domain_num(domain_);
         void *data_old = layer.data;
         void *data_new = CustomData_duplicate_referenced_layer_named(
-            custom_data, stored_type_, layer.name, domain_size);
+            custom_data, stored_type_, layer.name, domain_num);
         if (data_old != data_new) {
           if (custom_data_access_.update_custom_data_pointers) {
             custom_data_access_.update_custom_data_pointers(component);
           }
         }
-        return {as_write_attribute_(layer.data, domain_size), domain_};
+        return {as_write_attribute_(layer.data, domain_num), domain_};
       }
     }
   }
@@ -612,8 +611,8 @@ bool NamedLegacyCustomDataProvider::try_delete(GeometryComponent &component,
     const CustomDataLayer &layer = custom_data->layers[i];
     if (layer.type == stored_type_) {
       if (custom_data_layer_matches_attribute_id(layer, attribute_id)) {
-        const int domain_size = component.attribute_domain_size(domain_);
-        CustomData_free_layer(custom_data, stored_type_, domain_size, i);
+        const int domain_num = component.attribute_domain_num(domain_);
+        CustomData_free_layer(custom_data, stored_type_, domain_num, i);
         if (custom_data_access_.update_custom_data_pointers) {
           custom_data_access_.update_custom_data_pointers(component);
         }
@@ -702,9 +701,9 @@ GVArray CustomDataAttributes::get_for_read(const AttributeIDRef &attribute_id,
 
   std::optional<GSpan> attribute = this->get_for_read(attribute_id);
   if (!attribute) {
-    const int domain_size = this->size_;
+    const int domain_num = this->size_;
     return GVArray::ForSingle(
-        *type, domain_size, (default_value == nullptr) ? type->default_value() : default_value);
+        *type, domain_num, (default_value == nullptr) ? type->default_value() : default_value);
   }
 
   if (attribute->type() == *type) {
@@ -822,7 +821,7 @@ bool GeometryComponent::attribute_domain_supported(const AttributeDomain domain)
   return providers->supported_domains().contains(domain);
 }
 
-int GeometryComponent::attribute_domain_size(const AttributeDomain UNUSED(domain)) const
+int GeometryComponent::attribute_domain_num(const AttributeDomain UNUSED(domain)) const
 {
   return 0;
 }
@@ -1157,8 +1156,8 @@ blender::GVArray GeometryComponent::attribute_get_for_read(const AttributeIDRef
   if (default_value == nullptr) {
     default_value = type->default_value();
   }
-  const int domain_size = this->attribute_domain_size(domain);
-  return blender::GVArray::ForSingle(*type, domain_size, default_value);
+  const int domain_num = this->attribute_domain_num(domain);
+  return blender::GVArray::ForSingle(*type, domain_num, default_value);
 }
 
 class GVMutableAttribute_For_OutputAttribute : public blender::GVArrayImpl_For_GSpan {
@@ -1267,10 +1266,10 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
     WriteAttributeLookup attribute = component.attribute_try_get_for_write(attribute_name);
     if (!attribute) {
       if (default_value) {
-        const int64_t domain_size = component.attribute_domain_size(domain);
+        const int64_t domain_num = component.attribute_domain_num(domain);
         component.attribute_try_create_builtin(
             attribute_name,
-            AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_size, default_value)));
+            AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_num, default_value)));
       }
       else {
         component.attribute_try_create_builtin(attribute_name, AttributeInitDefault());
@@ -1301,7 +1300,7 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
                            ignore_old_values);
   }
 
-  const int domain_size = component.attribute_domain_size(domain);
+  const int domain_num = component.attribute_domain_num(domain);
 
   WriteAttributeLookup attribute = component.attribute_try_get_for_write(attribute_id);
   if (!attribute) {
@@ -1310,7 +1309,7 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
           attribute_id,
           domain,
           data_type,
-          AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_size, default_value)));
+          AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_num, default_value)));
     }
     else {
       component.attribute_try_create(attribute_id, domain, data_type, AttributeInitDefault());
@@ -1333,8 +1332,7 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
 
   /* Allocate a new array that lives next to the existing attribute. It will overwrite the existing
    * attribute after processing is done. */
-  void *data = MEM_mallocN_aligned(
-      cpp_type->size() * domain_size, cpp_type->alignment(), __func__);
+  void *data = MEM_mallocN_aligned(cpp_type->size() * domain_num, cpp_type->alignment(), __func__);
   if (ignore_old_values) {
     /* This does nothing for trivially constructible types, but is necessary for correctness. */
     cpp_type->default_construct_n(data, domain);
@@ -1343,10 +1341,10 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
     /* Fill the temporary array with values from the existing attribute. */
     GVArray old_varray = component.attribute_get_for_read(
         attribute_id, domain, data_type, default_value);
-    old_varray.materialize_to_uninitialized(IndexRange(domain_size), data);
+    old_varray.materialize_to_uninitialized(IndexRange(domain_num), data);
   }
   GVMutableArray varray = GVMutableArray::For<GVMutableAttribute_For_OutputAttribute>(
-      GMutableSpan{*cpp_type, data, domain_size}, component, attribute_id);
+      GMutableSpan{*cpp_type, data, domain_num}, component, attribute_id);
 
   return OutputAttribute(std::move(varray), domain, save_output_attribute, true);
 }
@@ -1429,7 +1427,7 @@ GVArray IDAttributeFieldInput::get_varray_for_context(const GeometryComponent &c
   const StringRef name = get_random_id_attribute_name(domain);
   GVArray attribute = component.attribute_try_get_for_read(name, domain, CD_PROP_INT32);
   if (attribute) {
-    BLI_assert(attribute.size() == component.attribute_domain_size(domain));
+    BLI_assert(attribute.size() == component.attribute_domain_num(domain));
     return attribute;
   }
 
diff --git a/source/blender/blenkernel/intern/attribute_access_intern.hh b/source/blender/blenkernel/intern/attribute_access_intern.hh
index 8c021ed0e21..f0f47cb7a11 100644
--- a/source/blender/blenkernel/intern/attribute_access_intern.hh
+++ b/source/blender/blenkernel/intern/attribute_access_intern.hh
@@ -172,8 +172,8 @@ class CustomDataAttributeProvider final : public DynamicAttributesProvider {
  */
 class NamedLegacyCustomDataProvider final : public DynamicAttributesProvider {
  private:
-  using AsReadAttribute = GVArray (*)(const void *data, int domain_size);
-  using AsWriteAttribute = GVMutableArray (*)(void *data, int domain_size);
+  using AsReadAttribute = GVArray (*)(const void *data, int domain_num);
+  using AsWriteAttribute = GVMutableArray (*)(void *data, int domain_num);
   const AttributeDomain domain_;
   const CustomDataType attribute_type_;
   const CustomDataType stored_type_;
@@ -207,14 +207,14 @@ class NamedLegacyCustomDataProvider final : public DynamicAttributesProvider {
   void foreach_domain(const FunctionRef<void(AttributeDomain)> callback) const final;
 };
 
-template<typename T> GVArray make_array_read_attribute(const void *data, const int domain_size)
+template<typename T> GVArray make_array_read_attribute(const void *data, const int domain_num)
 {
-  return VArray<T>::ForSpan(Span<T>((const T *)data, domain_size));
+  return VArray<T>::ForSpan(Span<T>((const T *)data, domain_num));
 }
 
-template<typename T> GVMutableArray make_array_write_attribute(void *data, const int domain_size)
+template<typename T> GVMutableArray make_array_write_attribute(void *data, const int domain_num)
 {
-  return VMutableArray<T>::ForSpan(MutableSpan<T>((T *)data, domain_size));
+  return VMutableArray<T>::ForSpan(MutableSpan<T>((T *)data, domain_num));
 }
 
 /**
@@ -226,8 +226,8 @@ template<typename T> GVMutableArray make_array_write_attribute(void *data, const
  * if the stored type is the same as the attribute type.
  */
 class BuiltinCustomDataLayerProvider final : public BuiltinAttributeProvider {
-  using AsReadAttribute = GVArray (*)(const void *data, int domain_size);
-  using AsWriteAttribute = GVMutableArray (*)(void *data, int domain_size);
+  using AsReadAttribute = GVArray (*)(const void *data, int domain_num);
+  using AsWriteAttribute = GVMutableArray (*)(void *data, int domain_num);
   using UpdateOnRead = void (*)(const GeometryComponent &component);
   using UpdateOnWrite = void (*)(GeometryComponent &component);
   const CustomDataType stored_type_;
diff --git a/source/blender/blenkernel/intern/curve_catmull_rom.cc b/source/blender/blenkernel/intern/curve_catmull_rom.cc
index 2db183eea3e..4b2174c912c 100644
--- a/source/blender/blenkernel/intern/curve_catmull_rom.cc
+++ b/source/blender/blenkernel/intern/curve_catmull_rom.cc
@@ -9,11 +9,11 @@
 
 namespace blender::bke::curves::catmull_rom {
 
-int calculate_evaluated_size(const int points_num, const bool cyclic, const int resolution)
+int calculate_evaluated_num(const int points_num, const bool cyclic, const int resolution)
 {
-  const int eval_size = resolution * curve_segment_size(points_num, cyclic);
+  const int eval_num = resolution * curve_segment_num(points_num, cyclic);
   /* If the curve isn't cyclic, one last point is added to the final point. */
-  return cyclic ? eval_size : eval_size + 1;
+  return cyclic ? eval_num : eval_num + 1;
 }
 
 /* Adapted from Cycles #catmull_rom_basis_eval function. */
@@ -46,7 +46,7 @@ static void interpolate_to_evaluated(const Span<T> src,
                                      MutableSpan<T> dst)
 
 {
-  BLI_assert(dst.size() == calculate_evaluated_size(src.size(), cyclic, resolution));
+  BLI_assert(dst.size() == calculate_evaluated_num(src.size(), cyclic, resolution));
 
   /* - First deal with one and two point curves need special attention.
    * - Then evaluate the first and last segment(s) whose control points need to wrap around
diff --git a/source/blender/blenkernel/intern/curve_eval.cc b/source/blender/blenkernel/intern/curve_eval.cc
index 3d9dd3ecf31..c507e7934a8 100644
--- a/source/blender/blenkernel/intern/curve_eval.cc
+++ b/source/blender/blenkernel/intern/curve_eval.cc
@@ -117,7 +117,7 @@ float CurveEval::total_length() const
   return length;
 }
 
-int CurveEval::total_control_point_size() const
+int CurveEval::total_control_point_num() const
 {
   int count = 0;
   for (const SplinePtr &spline : this->splines()) {
@@ -144,7 +144,7 @@ blender::Array<int> CurveEval::evaluated_point_offsets() const
   int offset = 0;
   for (const int i : splines_.index_range()) {
     offsets[i] = offset;
-    offset += splines_[i]->evaluated_points_size();
+    offset += splines_[i]->evaluated_points_num();
   }
   offsets.last() = offset;
   return offsets;
@@ -463,7 +463,7 @@ std::unique_ptr<CurveEval> curves_to_curve_eval(const Curves &curves)
 
 Curves *curve_eval_to_curves(const CurveEval &curve_eval)
 {
-  Curves *curves = blender::bke::curves_new_nomain(curve_eval.total_control_point_size(),
+  Curves *curves = blender::bke::curves_new_nomain(curve_eval.total_control_point_num(),
                                                    curve_eval.splines().size());
   CurveComponent dst_component;
   dst_component.replace(curves, GeometryOwnershipType::Editable);
diff --git a/source/blender/blenkernel/intern/curve_nurbs.cc b/source/blender/blenkernel/intern/curve_nurbs.cc
index 45440358221..cd6b64e9a03 100644
--- a/source/blender/blenkernel/intern/curve_nurbs.cc
+++ b/source/blender/blenkernel/intern/curve_nurbs.cc
@@ -10,10 +10,10 @@
 
 namespace blender::bke::curves::nurbs {
 
-bool check_valid_size_and_order(const int points_num,
-                                const int8_t order,
-                                const bool cyclic,
-                                const KnotsMode knots_mode)
+bool check_valid_num_and_order(const int points_num,
+                               const int8_t order,
+                               const bool cyclic,
+                               const KnotsMode knots_mode)
 {
   if (points_num < order) {
     return false;
@@ -29,19 +29,19 @@ bool check_valid_size_and_order(const int points_num,
   return true;
 }
 
-int calculate_evaluated_size(const int points_num,
-                             const int8_t order,
-                             const bool cyclic,
-                             const int resolution,
-                             const KnotsMode knots_mode)
+int calculate_evaluated_num(const int points_num,
+                            const int8_t order,
+                            const bool cyclic,
+                            const int resolution,
+                            const KnotsMode knots_mode)
 {
-  if (!check_valid_size_and_order(points_num, order, cyclic, knots_mode)) {
+  if (!check_valid_num_and_order(points_num, order, cyclic, knots_mode)) {
     return points_num;
   }
-  return resolution * curve_segment_size(points_num, cyclic);
+  return resolution * curve_segment_num(points_num, cyclic);
 }
 
-int knots_size(const int points_num, const int8_t order, const bool cyclic)
+int knots_num(const int points_num, const int8_t order, const bool cyclic)
 {
   if (cyclic) {
     return points_num + order * 2 - 1;
@@ -55,7 +55,7 @@ void calculate_knots(const int points_num,
                      const bool cyclic,
                      MutableSpan<float> knots)
 {
-  BLI_assert(knots.size() == knots_size(points_num, order, cyclic));
+  BLI_assert(knots.size() == knots_num(points_num, order, cyclic));
   UNUSED_VARS_NDEBUG(points_num);
 
   const bool is_bezier = ELEM(mode, NURBS_KNOT_MODE_BEZIER, NURBS_KNOT_MODE_ENDPOINT_BEZIER);
@@ -147,7 +147,7 @@ static void calculate_basis_for_point(const float parameter,
 }
 
 void calculate_basis_cache(const int points_num,
-                           const int evaluated_size,
+                           const int evaluated_num,
                            const int8_t order,
                            const bool cyclic,
                            const Span<float> knots,
@@ -157,10 +157,10 @@ void calculate_basis_cache(const int points_num,
 
   const int8_t degree = order - 1;
 
-  basis_cache.weights.resize(evaluated_size * order);
-  basis_cache.start_indices.resize(evaluated_size);
+  basis_cache.weights.resize(evaluated_num * order);
+  basis_cache.start_indices.resize(evaluated_num);
 
-  if (evaluated_size == 0) {
+  if (evaluated_num == 0) {
     return;
   }
 
@@ -168,12 +168,12 @@ void calculate_basis_cache(const int points_num,
   MutableSpan<int> basis_start_indices(basis_cache.start_indices);
 
   const int last_control_point_index = cyclic ? points_num + degree : points_num;
-  const int evaluated_segment_size = curve_segment_size(evaluated_size, cyclic);
+  const int evaluated_segment_num = curve_segment_num(evaluated_num, cyclic);
 
   const float start = knots[degree];
   const float end = knots[last_control_point_index];
-  const float step = (end - start) / evaluated_segment_size;
-  for (const int i : IndexRange(evaluated_size)) {
+  const float step = (end - start) / evaluated_segment_num;
+  for (const int i : IndexRange(evaluated_num)) {
     /* Clamp parameter due to floating point inaccuracy. */
     const float parameter = std::clamp(start + step * i, knots[0], knots[points_num + degree]);
 
diff --git a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
index ef921797698..0cd324cfe2c 100644
--- a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
+++ b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
@@ -39,8 +39,8 @@ static void fill_mesh_topology(const int vert_offset,
                                MutableSpan<MLoop> loops,
                                MutableSpan<MPoly> polys)
 {
-  const int main_segment_num = curves::curve_segment_size(main_point_num, main_cyclic);
-  const int profile_segment_num = curves::curve_segment_size(profile_point_num, profile_cyclic);
+  const int main_segment_num = curves::curve_segment_num(main_point_num, main_cyclic);
+  const int profile_segment_num = curves::curve_segment_num(profile_point_num, profile_cyclic);
 
   if (profile_point_num == 1) {
     for (const int i : IndexRange(main_point_num - 1)) {
@@ -134,9 +134,9 @@ static void fill_mesh_topology(const int vert_offset,
 
   const bool has_caps = fill_caps && !main_cyclic && profile_cyclic;
   if (has_caps) {
-    const int poly_size = main_segment_num * profile_segment_num;
-    const int cap_loop_offset = loop_offset + poly_size * 4;
-    const int cap_poly_offset = poly_offset + poly_size;
+    const int poly_num = main_segment_num * profile_segment_num;
+    const int cap_loop_offset = loop_offset + poly_num * 4;
+    const int cap_poly_offset = poly_offset + poly_num;
 
     MPoly &poly_start = polys[cap_poly_offset];
     poly_start.loopstart = cap_loop_offset;
@@ -273,7 +273,7 @@ static ResultOffsets calculate_result_offsets(const CurvesInfo &info, const bool
   for (const int i_main : info.main.curves_range()) {
     const bool main_cyclic = info.main_cyclic[i_main];
     const int main_point_num = info.main.evaluated_points_for_curve(i_main).size();
-    const int main_segment_num = curves::curve_segment_size(main_point_num, main_cyclic);
+    const int main_segment_num = curves::curve_segment_num(main_point_num, main_cyclic);
     for (const int i_profile : info.profile.curves_range()) {
       result.vert[mesh_index] = vert_offset;
       result.edge[mesh_index] = edge_offset;
@@ -285,8 +285,7 @@ static ResultOffsets calculate_result_offsets(const CurvesInfo &info, const bool
 
       const bool profile_cyclic = info.profile_cyclic[i_profile];
       const int profile_point_num = info.profile.evaluated_points_for_curve(i_profile).size();
-      const int profile_segment_num = curves::curve_segment_size(profile_point_num,
-                                                                 profile_cyclic);
+      const int profile_segment_num = curves::curve_segment_num(profile_point_num, profile_cyclic);
 
       const bool has_caps = fill_caps && !main_cyclic && profile_cyclic;
       const int tube_face_num = main_segment_num * profile_segment_num;
@@ -408,8 +407,8 @@ static void foreach_curve_combination(const CurvesInfo &info,
                          profile_points,
                          main_cyclic,
                          profile_cyclic,
-                         curves::curve_segment_size(main_points.size(), main_cyclic),
-                         curves::curve_segment_size(profile_points.size(), profile_cyclic),
+                         curves::curve_segment_num(main_points.size(), main_cyclic),
+                         curves::curve_segment_num(profile_points.size(), profile_cyclic),
                          offsets_to_range(offsets.vert.as_span(), i),
                          offsets_to_range(offsets.edge.as_span(), i),
                          offsets_to_range(offsets.poly.as_span(), i),
diff --git a/source/blender/blenkernel/intern/curves_geometry.cc b/source/blender/blenkernel/intern/curves_geometry.cc
index 9e7f5f519ba..0fd58a52f81 100644
--- a/source/blender/blenkernel/intern/curves_geometry.cc
+++ b/source/blender/blenkernel/intern/curves_geometry.cc
@@ -158,7 +158,7 @@ CurvesGeometry::~CurvesGeometry()
 /** \name Accessors
  * \{ */
 
-static int domain_size(const CurvesGeometry &curves, const AttributeDomain domain)
+static int domain_num(const CurvesGeometry &curves, const AttributeDomain domain)
 {
   return domain == ATTR_DOMAIN_POINT ? curves.points_num() : curves.curves_num();
 }
@@ -180,15 +180,15 @@ static VArray<T> get_varray_attribute(const CurvesGeometry &curves,
                                       const StringRefNull name,
                                       const T default_value)
 {
-  const int size = domain_size(curves, domain);
+  const int num = domain_num(curves, domain);
   const CustomDataType type = cpp_type_to_custom_data_type(CPPType::get<T>());
   const CustomData &custom_data = domain_custom_data(curves, domain);
 
   const T *data = (const T *)CustomData_get_layer_named(&custom_data, type, name.c_str());
   if (data != nullptr) {
-    return VArray<T>::ForSpan(Span<T>(data, size));
+    return VArray<T>::ForSpan(Span<T>(data, num));
   }
-  return VArray<T>::ForSingle(default_value, size);
+  return VArray<T>::ForSingle(default_value, num);
 }
 
 template<typename T>
@@ -196,7 +196,7 @@ static Span<T> get_span_attribute(const CurvesGeometry &curves,
                                   const AttributeDomain domain,
                                   const StringRefNull name)
 {
-  const int size = domain_size(curves, domain);
+  const int num = domain_num(curves, domain);
   const CustomData &custom_data = domain_custom_data(curves, domain);
   const CustomDataType type = cpp_type_to_custom_data_type(CPPType::get<T>());
 
@@ -204,7 +204,7 @@ static Span<T> get_span_attribute(const CurvesGeometry &curves,
   if (data == nullptr) {
     return {};
   }
-  return {data, size};
+  return {data, num};
 }
 
 template<typename T>
@@ -213,19 +213,19 @@ static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves,
                                             const StringRefNull name,
                                             const T default_value = T())
 {
-  const int size = domain_size(curves, domain);
+  const int num = domain_num(curves, domain);
   const CustomDataType type = cpp_type_to_custom_data_type(CPPType::get<T>());
   CustomData &custom_data = domain_custom_data(curves, domain);
 
   T *data = (T *)CustomData_duplicate_referenced_layer_named(
-      &custom_data, type, name.c_str(), size);
+      &custom_data, type, name.c_str(), num);
   if (data != nullptr) {
-    return {data, size};
+    return {data, num};
   }
   data = (T *)CustomData_add_layer_named(
-      &custom_data, type, CD_CALLOC, nullptr, size, name.c_str());
-  MutableSpan<T> span = {data, size};
-  if (size > 0 && span.first() != default_value) {
+      &custom_data, type, CD_CALLOC, nullptr, num, name.c_str());
+  MutableSpan<T> span = {data, num};
+  if (num > 0 && span.first() != default_value) {
     span.fill(default_value);
   }
   return span;
@@ -444,12 +444,12 @@ MutableSpan<float2> CurvesGeometry::surface_triangle_coords_for_write()
 /** \name Evaluation
  * \{ */
 
-template<typename SizeFn> void build_offsets(MutableSpan<int> offsets, const SizeFn &size_fn)
+template<typename CountFn> void build_offsets(MutableSpan<int> offsets, const CountFn &count_fn)
 {
   int offset = 0;
   for (const int i : offsets.drop_back(1).index_range()) {
     offsets[i] = offset;
-    offset += size_fn(i);
+    offset += count_fn(i);
   }
   offsets.last() = offset;
 }
@@ -472,7 +472,7 @@ static void calculate_evaluated_offsets(const CurvesGeometry &curves,
     const IndexRange points = curves.points_for_curve(curve_index);
     switch (types[curve_index]) {
       case CURVE_TYPE_CATMULL_ROM:
-        return curves::catmull_rom::calculate_evaluated_size(
+        return curves::catmull_rom::calculate_evaluated_num(
             points.size(), cyclic[curve_index], resolution[curve_index]);
       case CURVE_TYPE_POLY:
         return points.size();
@@ -484,11 +484,11 @@ static void calculate_evaluated_offsets(const CurvesGeometry &curves,
                                                     bezier_evaluated_offsets.slice(points));
         return bezier_evaluated_offsets[points.last()];
       case CURVE_TYPE_NURBS:
-        return curves::nurbs::calculate_evaluated_size(points.size(),
-                                                       nurbs_orders[curve_index],
-                                                       cyclic[curve_index],
-                                                       resolution[curve_index],
-                                                       KnotsMode(nurbs_knots_modes[curve_index]));
+        return curves::nurbs::calculate_evaluated_num(points.size(),
+                                                      nurbs_orders[curve_index],
+                                                      cyclic[curve_index],
+                                                      resolution[curve_index],
+                                                      KnotsMode(nurbs_knots_modes[curve_index]));
     }
     BLI_assert_unreachable();
     return 0;
@@ -587,13 +587,13 @@ void CurvesGeometry::ensure_nurbs_basis_cache() const
         const bool is_cyclic = cyclic[curve_index];
         const KnotsMode mode = KnotsMode(knots_modes[curve_index]);
 
-        if (!curves::nurbs::check_valid_size_and_order(points.size(), order, is_cyclic, mode)) {
+        if (!curves::nurbs::check_valid_num_and_order(points.size(), order, is_cyclic, mode)) {
           basis_caches[curve_index].invalid = true;
           continue;
         }
 
-        const int knots_size = curves::nurbs::knots_size(points.size(), order, is_cyclic);
-        Array<float> knots(knots_size);
+        const int knots_num = curves::nurbs::knots_num(points.size(), order, is_cyclic);
+        Array<float> knots(knots_num);
         curves::nurbs::calculate_knots(points.size(), mode, order, is_cyclic, knots);
         curves::nurbs::calculate_basis_cache(points.size(),
                                              evaluated_points.size(),
@@ -914,8 +914,8 @@ void CurvesGeometry::ensure_evaluated_lengths() const
   threading::isolate_task([&]() {
     /* Use an extra length value for the final cyclic segment for a consistent size
      * (see comment on #evaluated_length_cache). */
-    const int total_size = this->evaluated_points_num() + this->curves_num();
-    this->runtime->evaluated_length_cache.resize(total_size);
+    const int total_num = this->evaluated_points_num() + this->curves_num();
+    this->runtime->evaluated_length_cache.resize(total_num);
     MutableSpan<float> evaluated_lengths = this->runtime->evaluated_length_cache;
 
     Span<float3> evaluated_positions = this->evaluated_positions();
diff --git a/source/blender/blenkernel/intern/geometry_component_curve.cc b/source/blender/blenkernel/intern/geometry_component_curve.cc
index f409389e463..a28afc8ddca 100644
--- a/source/blender/blenkernel/intern/geometry_component_curve.cc
+++ b/source/blender/blenkernel/intern/geometry_component_curve.cc
@@ -114,7 +114,7 @@ void CurveComponentLegacy::ensure_owns_direct_data()
 /** \name Attribute Access Helper Functions
  * \{ */
 
-int CurveComponentLegacy::attribute_domain_size(const AttributeDomain domain) const
+int CurveComponentLegacy::attribute_domain_num(const AttributeDomain domain) const
 {
   if (curve_ == nullptr) {
     return 0;
@@ -251,8 +251,8 @@ template<typename T> class VArray_For_SplineToPoint final : public VArrayImpl<T>
 
   void materialize(const IndexMask mask, MutableSpan<T> r_span) const final
   {
-    const int total_size = offsets_.last();
-    if (mask.is_range() && mask.as_range() == IndexRange(total_size)) {
+    const int total_num = offsets_.last();
+    if (mask.is_range() && mask.as_range() == IndexRange(total_num)) {
       for (const int spline_index : original_data_.index_range()) {
         const int offset = offsets_[spline_index];
         const int next_offset = offsets_[spline_index + 1];
@@ -273,8 +273,8 @@ template<typename T> class VArray_For_SplineToPoint final : public VArrayImpl<T>
   void materialize_to_uninitialized(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     T *dst = r_span.data();
-    const int total_size = offsets_.last();
-    if (mask.is_range() && mask.as_range() == IndexRange(total_size)) {
+    const int total_num = offsets_.last();
+    if (mask.is_range() && mask.as_range() == IndexRange(total_num)) {
       for (const int spline_index : original_data_.index_range()) {
         const int offset = offsets_[spline_index];
         const int next_offset = offsets_[spline_index + 1];
@@ -415,7 +415,7 @@ class BuiltinSplineAttributeProvider final : public BuiltinAttributeProvider {
 
   bool exists(const GeometryComponent &component) const final
   {
-    return component.attribute_domain_size(ATTR_DOMAIN_CURVE) != 0;
+    return component.attribute_domain_num(ATTR_DOMAIN_CURVE) != 0;
   }
 };
 
@@ -495,8 +495,8 @@ static void point_attribute_materialize(Span<Span<T>> data,
                                         const IndexMask mask,
                                         MutableSpan<T> r_span)
 {
-  const int total_size = offsets.last();
-  if (mask.is_range() && mask.as_range() == IndexRange(total_size)) {
+  const int total_num = offsets.last();
+  if (mask.is_range() && mask.as_range() == IndexRange(total_num)) {
     for (const int spline_index : data.index_range()) {
       const int offset = offsets[spline_index];
       const int next_offset = offsets[spline_index + 1];
@@ -541,8 +541,8 @@ static void point_attribute_materialize_to_uninitialized(Span<Span<T>> data,
                                                          MutableSpan<T> r_span)
 {
   T *dst = r_span.data();
-  const int total_size = offsets.last();
-  if (mask.is_range() && mask.as_range() == IndexRange(total_size)) {
+  const int total_num = offsets.last();
+  if (mask.is_range() && mask.as_range() == IndexRange(total_num)) {
     for (const int spline_index : data.index_range()) {
       const int offset = offsets[spline_index];
       const int next_offset = offsets[spline_index + 1];
@@ -589,13 +589,13 @@ static GVArray varray_from_initializer(const AttributeInit &initializer,
     case AttributeInit::Type::VArray:
       return static_cast<const AttributeInitVArray &>(initializer).varray;
     case AttributeInit::Type::MoveArray:
-      int total_size = 0;
+      int total_num = 0;
       for (const SplinePtr &spline : splines) {
-        total_size += spline->size();
+        total_num += spline->size();
       }
       return GVArray::ForSpan(GSpan(*bke::custom_data_type_to_cpp_type(data_type),
                                     static_cast<const AttributeInitMove &>(initializer).data,
-                                    total_size));
+                                    total_num));
   }
   BLI_assert_unreachable();
   return {};
@@ -1168,7 +1168,7 @@ class BezierHandleAttributeProvider : public BuiltinAttributeProvider {
     }
 
     return curve->has_spline_with_type(CURVE_TYPE_BEZIER) &&
-           component.attribute_domain_size(ATTR_DOMAIN_POINT) != 0;
+           component.attribute_domain_num(ATTR_DOMAIN_POINT) != 0;
   }
 };
 
diff --git a/source/blender/blenkernel/intern/geometry_component_curves.cc b/source/blender/blenkernel/intern/geometry_component_curves.cc
index 7c4a7db6462..b565143d08f 100644
--- a/source/blender/blenkernel/intern/geometry_component_curves.cc
+++ b/source/blender/blenkernel/intern/geometry_component_curves.cc
@@ -308,7 +308,7 @@ bool CurveLengthFieldInput::is_equal_to(const fn::FieldNode &other) const
 /** \name Attribute Access Helper Functions
  * \{ */
 
-int CurveComponent::attribute_domain_size(const AttributeDomain domain) const
+int CurveComponent::attribute_domain_num(const AttributeDomain domain) const
 {
   if (curves_ == nullptr) {
     return 0;
diff --git a/source/blender/blenkernel/intern/geometry_component_instances.cc b/source/blender/blenkernel/intern/geometry_component_instances.cc
index 0dc6f486d28..e56a7ca4dd8 100644
--- a/source/blender/blenkernel/intern/geometry_component_instances.cc
+++ b/source/blender/blenkernel/intern/geometry_component_instances.cc
@@ -79,7 +79,7 @@ void InstancesComponent::add_instance(const int instance_handle, const float4x4
   BLI_assert(instance_handle < references_.size());
   instance_reference_handles_.append(instance_handle);
   instance_transforms_.append(transform);
-  attributes_.reallocate(this->instances_amount());
+  attributes_.reallocate(this->instances_num());
 }
 
 blender::Span<int> InstancesComponent::instance_reference_handles() const
@@ -183,7 +183,7 @@ void InstancesComponent::remove_unused_references()
   using namespace blender;
   using namespace blender::bke;
 
-  const int tot_instances = this->instances_amount();
+  const int tot_instances = this->instances_num();
   const int tot_references_before = references_.size();
 
   if (tot_instances == 0) {
@@ -258,12 +258,12 @@ void InstancesComponent::remove_unused_references()
   });
 }
 
-int InstancesComponent::instances_amount() const
+int InstancesComponent::instances_num() const
 {
   return instance_transforms_.size();
 }
 
-int InstancesComponent::references_amount() const
+int InstancesComponent::references_num() const
 {
   return references_.size();
 }
@@ -358,7 +358,7 @@ blender::Span<int> InstancesComponent::almost_unique_ids() const
     }
   }
   else {
-    almost_unique_ids_.reinitialize(this->instances_amount());
+    almost_unique_ids_.reinitialize(this->instances_num());
     for (const int i : almost_unique_ids_.index_range()) {
       almost_unique_ids_[i] = i;
     }
@@ -366,12 +366,12 @@ blender::Span<int> InstancesComponent::almost_unique_ids() const
   return almost_unique_ids_;
 }
 
-int InstancesComponent::attribute_domain_size(const AttributeDomain domain) const
+int InstancesComponent::attribute_domain_num(const AttributeDomain domain) const
 {
   if (domain != ATTR_DOMAIN_INSTANCE) {
     return 0;
   }
-  return this->instances_amount();
+  return this->instances_num();
 }
 
 blender::bke::CustomDataAttributes &InstancesComponent::attributes()
diff --git a/source/blender/blenkernel/intern/geometry_component_mesh.cc b/source/blender/blenkernel/intern/geometry_component_mesh.cc
index fb39861d3e7..5ac9a03f43c 100644
--- a/source/blender/blenkernel/intern/geometry_component_mesh.cc
+++ b/source/blender/blenkernel/intern/geometry_component_mesh.cc
@@ -169,7 +169,7 @@ VArray<float3> mesh_normals_varray(const MeshComponent &mesh_component,
 /** \name Attribute Access
  * \{ */
 
-int MeshComponent::attribute_domain_size(const AttributeDomain domain) const
+int MeshComponent::attribute_domain_num(const AttributeDomain domain) const
 {
   if (mesh_ == nullptr) {
     return 0;
@@ -839,20 +839,20 @@ static const Mesh *get_mesh_from_component_for_read(const GeometryComponent &com
 namespace blender::bke {
 
 template<typename StructT, typename ElemT, ElemT (*GetFunc)(const StructT &)>
-static GVArray make_derived_read_attribute(const void *data, const int domain_size)
+static GVArray make_derived_read_attribute(const void *data, const int domain_num)
 {
   return VArray<ElemT>::template ForDerivedSpan<StructT, GetFunc>(
-      Span<StructT>((const StructT *)data, domain_size));
+      Span<StructT>((const StructT *)data, domain_num));
 }
 
 template<typename StructT,
          typename ElemT,
          ElemT (*GetFunc)(const StructT &),
          void (*SetFunc)(StructT &, ElemT)>
-static GVMutableArray make_derived_write_attribute(void *data, const int domain_size)
+static GVMutableArray make_derived_write_attribute(void *data, const int domain_num)
 {
   return VMutableArray<ElemT>::template ForDerivedSpan<StructT, GetFunc, SetFunc>(
-      MutableSpan<StructT>((StructT *)data, domain_size));
+      MutableSpan<StructT>((StructT *)data, domain_num));
 }
 
 static float3 get_vertex_position(const MVert &vert)
@@ -1160,7 +1160,7 @@ class NormalAttributeProvider final : public BuiltinAttributeProvider {
 
   bool exists(const GeometryComponent &component) const final
   {
-    return component.attribute_domain_size(ATTR_DOMAIN_FACE) != 0;
+    return component.attribute_domain_num(ATTR_DOMAIN_FACE) != 0;
   }
 };
 
diff --git a/source/blender/blenkernel/intern/geometry_component_pointcloud.cc b/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
index 400e0ea5e15..6de123c7cb9 100644
--- a/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
+++ b/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
@@ -104,7 +104,7 @@ void PointCloudComponent::ensure_owns_direct_data()
 /** \name Attribute Access
  * \{ */
 
-int PointCloudComponent::attribute_domain_size(const AttributeDomain domain) const
+int PointCloudComponent::attribute_domain_num(const AttributeDomain domain) const
 {
   if (pointcloud_ == nullptr) {
     return 0;
diff --git a/source/blender/blenkernel/intern/geometry_set.cc b/source/blender/blenkernel/intern/geometry_set.cc
index 2bd8b643899..40e36ced199 100644
--- a/source/blender/blenkernel/intern/geometry_set.cc
+++ b/source/blender/blenkernel/intern/geometry_set.cc
@@ -272,7 +272,7 @@ bool GeometrySet::has_pointcloud() const
 bool GeometrySet::has_instances() const
 {
   const InstancesComponent *component = this->get_component_for_read<InstancesComponent>();
-  return component != nullptr && component->instances_amount() >= 1;
+  return component != nullptr && component->instances_num() >= 1;
 }
 
 bool GeometrySet::has_volume() const
diff --git a/source/blender/blenkernel/intern/spline_base.cc b/source/blender/blenkernel/intern/spline_base.cc
index 7704a74841a..e8c7aff75d1 100644
--- a/source/blender/blenkernel/intern/spline_base.cc
+++ b/source/blender/blenkernel/intern/spline_base.cc
@@ -116,15 +116,15 @@ void Spline::reverse()
   this->mark_cache_invalid();
 }
 
-int Spline::evaluated_edges_size() const
+int Spline::evaluated_edges_num() const
 {
-  const int eval_size = this->evaluated_points_size();
-  if (eval_size < 2) {
+  const int eval_num = this->evaluated_points_num();
+  if (eval_num < 2) {
     /* Two points are required for an edge. */
     return 0;
   }
 
-  return this->is_cyclic_ ? eval_size : eval_size - 1;
+  return this->is_cyclic_ ? eval_num : eval_num - 1;
 }
 
 float Spline::length() const
@@ -133,11 +133,11 @@ float Spline::length() const
   return lengths.is_empty() ? 0.0f : this->evaluated_lengths().last();
 }
 
-int Spline::segments_size() const
+int Spline::segments_num() const
 {
-  const int size = this->size();
+  const int num = this->size();
 
-  return is_cyclic_ ? size : size - 1;
+  return is_cyclic_ ? num : num - 1;
 }
 
 bool Spline::is_cyclic() const
@@ -177,7 +177,7 @@ Span<float> Spline::evaluated_lengths() const
     return evaluated_lengths_cache_;
   }
 
-  const int total = evaluated_edges_size();
+  const int total = evaluated_edges_num();
   evaluated_lengths_cache_.resize(total);
   if (total != 0) {
     Span<float3> positions = this->evaluated_positions();
@@ -242,8 +242,8 @@ Span<float3> Spline::evaluated_tangents() const
     return evaluated_tangents_cache_;
   }
 
-  const int eval_size = this->evaluated_points_size();
-  evaluated_tangents_cache_.resize(eval_size);
+  const int eval_num = this->evaluated_points_num();
+  evaluated_tangents_cache_.resize(eval_num);
 
   Span<float3> positions = this->evaluated_positions();
 
@@ -369,8 +369,8 @@ Span<float3> Spline::evaluated_normals() const
     return evaluated_normals_cache_;
   }
 
-  const int eval_size = this->evaluated_points_size();
-  evaluated_normals_cache_.resize(eval_size);
+  const int eval_num = this->evaluated_points_num();
+  evaluated_normals_cache_.resize(eval_num);
 
   Span<float3> tangents = this->evaluated_tangents();
   MutableSpan<float3> normals = evaluated_normals_cache_;
@@ -410,7 +410,7 @@ Spline::LookupResult Spline::lookup_evaluated_length(const float length) const
 
   const float *offset = std::lower_bound(lengths.begin(), lengths.end(), length);
   const int index = offset - lengths.begin();
-  const int next_index = (index == this->evaluated_points_size() - 1) ? 0 : index + 1;
+  const int next_index = (index == this->evaluated_points_num() - 1) ? 0 : index + 1;
 
   const float previous_length = (index == 0) ? 0.0f : lengths[index - 1];
   const float length_in_segment = length - previous_length;
@@ -420,30 +420,30 @@ Spline::LookupResult Spline::lookup_evaluated_length(const float length) const
   return LookupResult{index, next_index, factor};
 }
 
-Array<float> Spline::sample_uniform_index_factors(const int samples_size) const
+Array<float> Spline::sample_uniform_index_factors(const int samples_num) const
 {
   const Span<float> lengths = this->evaluated_lengths();
 
-  BLI_assert(samples_size > 0);
-  Array<float> samples(samples_size);
+  BLI_assert(samples_num > 0);
+  Array<float> samples(samples_num);
 
   samples[0] = 0.0f;
-  if (samples_size == 1) {
+  if (samples_num == 1) {
     return samples;
   }
 
   const float total_length = this->length();
-  const float sample_length = total_length / (samples_size - (is_cyclic_ ? 0 : 1));
+  const float sample_length = total_length / (samples_num - (is_cyclic_ ? 0 : 1));
 
   /* Store the length at the previous evaluated point in a variable so it can
    * start out at zero (the lengths array doesn't contain 0 for the first point). */
   float prev_length = 0.0f;
   int i_sample = 1;
-  for (const int i_evaluated : IndexRange(this->evaluated_edges_size())) {
+  for (const int i_evaluated : IndexRange(this->evaluated_edges_num())) {
     const float length = lengths[i_evaluated];
 
     /* Add every sample that fits in this evaluated edge. */
-    while ((sample_length * i_sample) < length && i_sample < samples_size) {
+    while ((sample_length * i_sample) < length && i_sample < samples_num) {
       const float factor = (sample_length * i_sample - prev_length) / (length - prev_length);
       samples[i_sample] = i_evaluated + factor;
       i_sample++;
@@ -454,8 +454,8 @@ Array<float> Spline::sample_uniform_index_factors(const int samples_size) const
 
   /* Zero lengths or float inaccuracies can cause invalid values, or simply
    * skip some, so set the values that weren't completed in the main loop. */
-  for (const int i : IndexRange(i_sample, samples_size - i_sample)) {
-    samples[i] = float(samples_size);
+  for (const int i : IndexRange(i_sample, samples_num - i_sample)) {
+    samples[i] = float(samples_num);
   }
 
   if (!is_cyclic_) {
@@ -468,23 +468,23 @@ Array<float> Spline::sample_uniform_index_factors(const int samples_size) const
 
 Spline::LookupResult Spline::lookup_data_from_index_factor(const float index_factor) const
 {
-  const int eval_size = this->evaluated_points_size();
+  const int eval_num = this->evaluated_points_num();
 
   if (is_cyclic_) {
-    if (index_factor < eval_size) {
+    if (index_factor < eval_num) {
       const int index = std::floor(index_factor);
-      const int next_index = (index < eval_size - 1) ? index + 1 : 0;
+      const int next_index = (index < eval_num - 1) ? index + 1 : 0;
       return LookupResult{index, next_index, index_factor - index};
     }
-    return LookupResult{eval_size - 1, 0, 1.0f};
+    return LookupResult{eval_num - 1, 0, 1.0f};
   }
 
-  if (index_factor < eval_size - 1) {
+  if (index_factor < eval_num - 1) {
     const int index = std::floor(index_factor);
     const int next_index = index + 1;
     return LookupResult{index, next_index, index_factor - index};
   }
-  return LookupResult{eval_size - 2, eval_size - 1, 1.0f};
+  return LookupResult{eval_num - 2, eval_num - 1, 1.0f};
 }
 
 void Spline::bounds_min_max(float3 &min, float3 &max, const bool use_evaluated) const
@@ -504,7 +504,7 @@ void Spline::sample_with_index_factors(const GVArray &src,
                                        Span<float> index_factors,
                                        GMutableSpan dst) const
 {
-  BLI_assert(src.size() == this->evaluated_points_size());
+  BLI_assert(src.size() == this->evaluated_points_num());
 
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
diff --git a/source/blender/blenkernel/intern/spline_bezier.cc b/source/blender/blenkernel/intern/spline_bezier.cc
index 8e207f93bf5..80515d0ef37 100644
--- a/source/blender/blenkernel/intern/spline_bezier.cc
+++ b/source/blender/blenkernel/intern/spline_bezier.cc
@@ -335,7 +335,7 @@ void BezierSpline::mark_cache_invalid()
   auto_handles_dirty_ = true;
 }
 
-int BezierSpline::evaluated_points_size() const
+int BezierSpline::evaluated_points_num() const
 {
   BLI_assert(this->size() > 0);
   return this->control_point_offsets().last();
@@ -502,12 +502,12 @@ Span<float> BezierSpline::evaluated_mappings() const
     return evaluated_mapping_cache_;
   }
 
-  const int size = this->size();
-  const int eval_size = this->evaluated_points_size();
-  evaluated_mapping_cache_.resize(eval_size);
+  const int num = this->size();
+  const int eval_num = this->evaluated_points_num();
+  evaluated_mapping_cache_.resize(eval_num);
   MutableSpan<float> mappings = evaluated_mapping_cache_;
 
-  if (eval_size == 1) {
+  if (eval_num == 1) {
     mappings.first() = 0.0f;
     mapping_cache_dirty_ = false;
     return mappings;
@@ -517,7 +517,7 @@ Span<float> BezierSpline::evaluated_mappings() const
 
   blender::threading::isolate_task([&]() {
     /* Isolate the task, since this is function is multi-threaded and holds a lock. */
-    calculate_mappings_linear_resolution(offsets, size, resolution_, is_cyclic_, mappings);
+    calculate_mappings_linear_resolution(offsets, num, resolution_, is_cyclic_, mappings);
   });
 
   mapping_cache_dirty_ = false;
@@ -535,15 +535,15 @@ Span<float3> BezierSpline::evaluated_positions() const
     return evaluated_position_cache_;
   }
 
-  const int size = this->size();
-  const int eval_size = this->evaluated_points_size();
-  evaluated_position_cache_.resize(eval_size);
+  const int num = this->size();
+  const int eval_num = this->evaluated_points_num();
+  evaluated_position_cache_.resize(eval_num);
 
   MutableSpan<float3> positions = evaluated_position_cache_;
 
-  if (size == 1) {
+  if (num == 1) {
     /* Use a special case for single point splines to avoid checking in #evaluate_segment. */
-    BLI_assert(eval_size == 1);
+    BLI_assert(eval_num == 1);
     positions.first() = positions_.first();
     position_cache_dirty_ = false;
     return positions;
@@ -556,7 +556,7 @@ Span<float3> BezierSpline::evaluated_positions() const
   const int grain_size = std::max(512 / resolution_, 1);
   blender::threading::isolate_task([&]() {
     /* Isolate the task, since this is function is multi-threaded and holds a lock. */
-    blender::threading::parallel_for(IndexRange(size - 1), grain_size, [&](IndexRange range) {
+    blender::threading::parallel_for(IndexRange(num - 1), grain_size, [&](IndexRange range) {
       for (const int i : range) {
         this->evaluate_segment(i, i + 1, positions.slice(offsets[i], offsets[i + 1] - offsets[i]));
       }
@@ -564,7 +564,7 @@ Span<float3> BezierSpline::evaluated_positions() const
   });
   if (is_cyclic_) {
     this->evaluate_segment(
-        size - 1, 0, positions.slice(offsets[size - 1], offsets[size] - offsets[size - 1]));
+        num - 1, 0, positions.slice(offsets[num - 1], offsets[num] - offsets[num - 1]));
   }
   else {
     /* Since evaluating the bezier segment doesn't add the final point,
@@ -579,23 +579,23 @@ Span<float3> BezierSpline::evaluated_positions() const
 BezierSpline::InterpolationData BezierSpline::interpolation_data_from_index_factor(
     const float index_factor) const
 {
-  const int size = this->size();
+  const int num = this->size();
 
   if (is_cyclic_) {
-    if (index_factor < size) {
+    if (index_factor < num) {
       const int index = std::floor(index_factor);
-      const int next_index = (index < size - 1) ? index + 1 : 0;
+      const int next_index = (index < num - 1) ? index + 1 : 0;
       return InterpolationData{index, next_index, index_factor - index};
     }
-    return InterpolationData{size - 1, 0, 1.0f};
+    return InterpolationData{num - 1, 0, 1.0f};
   }
 
-  if (index_factor < size - 1) {
+  if (index_factor < num - 1) {
     const int index = std::floor(index_factor);
     const int next_index = index + 1;
     return InterpolationData{index, next_index, index_factor - index};
   }
-  return InterpolationData{size - 2, size - 1, 1.0f};
+  return InterpolationData{num - 2, num - 1, 1.0f};
 }
 
 /* Use a spline argument to avoid adding this to the header. */
@@ -605,7 +605,7 @@ static void interpolate_to_evaluated_impl(const BezierSpline &spline,
                                           MutableSpan<T> dst)
 {
   BLI_assert(src.size() == spline.size());
-  BLI_assert(dst.size() == spline.evaluated_points_size());
+  BLI_assert(dst.size() == spline.evaluated_points_num());
   Span<float> mappings = spline.evaluated_mappings();
 
   for (const int i : dst.index_range()) {
@@ -627,8 +627,8 @@ GVArray BezierSpline::interpolate_to_evaluated(const GVArray &src) const
     return src;
   }
 
-  const int eval_size = this->evaluated_points_size();
-  if (eval_size == 1) {
+  const int eval_num = this->evaluated_points_num();
+  if (eval_num == 1) {
     return src;
   }
 
@@ -636,7 +636,7 @@ GVArray BezierSpline::interpolate_to_evaluated(const GVArray &src) const
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<blender::attribute_math::DefaultMixer<T>>) {
-      Array<T> values(eval_size);
+      Array<T> values(eval_num);
       interpolate_to_evaluated_impl<T>(*this, src.typed<T>(), values);
       new_varray = VArray<T>::ForContainer(std::move(values));
     }
diff --git a/source/blender/blenkernel/intern/spline_nurbs.cc b/source/blender/blenkernel/intern/spline_nurbs.cc
index 9d1d5a53a43..a7eeb82d854 100644
--- a/source/blender/blenkernel/intern/spline_nurbs.cc
+++ b/source/blender/blenkernel/intern/spline_nurbs.cc
@@ -124,19 +124,19 @@ void NURBSpline::mark_cache_invalid()
   length_cache_dirty_ = true;
 }
 
-int NURBSpline::evaluated_points_size() const
+int NURBSpline::evaluated_points_num() const
 {
-  if (!this->check_valid_size_and_order()) {
+  if (!this->check_valid_num_and_order()) {
     return 0;
   }
-  return resolution_ * this->segments_size();
+  return resolution_ * this->segments_num();
 }
 
 void NURBSpline::correct_end_tangents() const
 {
 }
 
-bool NURBSpline::check_valid_size_and_order() const
+bool NURBSpline::check_valid_num_and_order() const
 {
   if (this->size() < order_) {
     return false;
@@ -152,10 +152,10 @@ bool NURBSpline::check_valid_size_and_order() const
   return true;
 }
 
-int NURBSpline::knots_size() const
+int NURBSpline::knots_num() const
 {
-  const int size = this->size() + order_;
-  return is_cyclic_ ? size + order_ - 1 : size;
+  const int num = this->size() + order_;
+  return is_cyclic_ ? num + order_ - 1 : num;
 }
 
 void NURBSpline::calculate_knots() const
@@ -173,7 +173,7 @@ void NURBSpline::calculate_knots() const
    * Covers both Cyclic and EndPoint cases. */
   const int tail = is_cyclic_ ? 2 * order - 1 : (is_end_point ? order : 0);
 
-  knots_.resize(this->knots_size());
+  knots_.resize(this->knots_num());
   MutableSpan<float> knots = knots_;
 
   int r = head;
@@ -203,13 +203,13 @@ void NURBSpline::calculate_knots() const
 Span<float> NURBSpline::knots() const
 {
   if (!knots_dirty_) {
-    BLI_assert(knots_.size() == this->knots_size());
+    BLI_assert(knots_.size() == this->knots_num());
     return knots_;
   }
 
   std::lock_guard lock{knots_mutex_};
   if (!knots_dirty_) {
-    BLI_assert(knots_.size() == this->knots_size());
+    BLI_assert(knots_.size() == this->knots_num());
     return knots_;
   }
 
@@ -221,7 +221,7 @@ Span<float> NURBSpline::knots() const
 }
 
 static void calculate_basis_for_point(const float parameter,
-                                      const int size,
+                                      const int num,
                                       const int degree,
                                       const Span<float> knots,
                                       MutableSpan<float> r_weights,
@@ -231,7 +231,7 @@ static void calculate_basis_for_point(const float parameter,
 
   int start = 0;
   int end = 0;
-  for (const int i : IndexRange(size + degree)) {
+  for (const int i : IndexRange(num + degree)) {
     const bool knots_equal = knots[i] == knots[i + 1];
     if (knots_equal || parameter < knots[i] || parameter > knots[i + 1]) {
       continue;
@@ -248,7 +248,7 @@ static void calculate_basis_for_point(const float parameter,
 
   for (const int i_order : IndexRange(2, degree)) {
     if (end + i_order >= knots.size()) {
-      end = size + degree - i_order;
+      end = num + degree - i_order;
     }
     for (const int i : IndexRange(end - start + 1)) {
       const int knot_index = start + i;
@@ -284,16 +284,16 @@ const NURBSpline::BasisCache &NURBSpline::calculate_basis_cache() const
     return basis_cache_;
   }
 
-  const int size = this->size();
-  const int eval_size = this->evaluated_points_size();
+  const int num = this->size();
+  const int eval_num = this->evaluated_points_num();
 
   const int order = this->order();
   const int degree = order - 1;
 
-  basis_cache_.weights.resize(eval_size * order);
-  basis_cache_.start_indices.resize(eval_size);
+  basis_cache_.weights.resize(eval_num * order);
+  basis_cache_.start_indices.resize(eval_num);
 
-  if (eval_size == 0) {
+  if (eval_num == 0) {
     return basis_cache_;
   }
 
@@ -303,14 +303,14 @@ const NURBSpline::BasisCache &NURBSpline::calculate_basis_cache() const
   const Span<float> control_weights = this->weights();
   const Span<float> knots = this->knots();
 
-  const int last_control_point_index = is_cyclic_ ? size + degree : size;
+  const int last_control_point_index = is_cyclic_ ? num + degree : num;
 
   const float start = knots[degree];
   const float end = knots[last_control_point_index];
-  const float step = (end - start) / this->evaluated_edges_size();
-  for (const int i : IndexRange(eval_size)) {
+  const float step = (end - start) / this->evaluated_edges_num();
+  for (const int i : IndexRange(eval_num)) {
     /* Clamp parameter due to floating point inaccuracy. */
-    const float parameter = std::clamp(start + step * i, knots[0], knots[size + degree]);
+    const float parameter = std::clamp(start + step * i, knots[0], knots[num + degree]);
 
     MutableSpan<float> point_weights = basis_weights.slice(i * order, order);
 
@@ -318,7 +318,7 @@ const NURBSpline::BasisCache &NURBSpline::calculate_basis_cache() const
         parameter, last_control_point_index, degree, knots, point_weights, basis_start_indices[i]);
 
     for (const int j : point_weights.index_range()) {
-      const int point_index = (basis_start_indices[i] + j) % size;
+      const int point_index = (basis_start_indices[i] + j) % num;
       point_weights[j] *= control_weights[point_index];
     }
   }
@@ -333,7 +333,7 @@ void interpolate_to_evaluated_impl(const NURBSpline::BasisCache &basis_cache,
                                    const blender::VArray<T> &src,
                                    MutableSpan<T> dst)
 {
-  const int size = src.size();
+  const int num = src.size();
   blender::attribute_math::DefaultMixer<T> mixer(dst);
 
   for (const int i : dst.index_range()) {
@@ -341,7 +341,7 @@ void interpolate_to_evaluated_impl(const NURBSpline::BasisCache &basis_cache,
     const int start_index = basis_cache.start_indices[i];
 
     for (const int j : point_weights.index_range()) {
-      const int point_index = (start_index + j) % size;
+      const int point_index = (start_index + j) % num;
       mixer.mix_in(i, src[point_index], point_weights[j]);
     }
   }
@@ -363,7 +363,7 @@ GVArray NURBSpline::interpolate_to_evaluated(const GVArray &src) const
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<blender::attribute_math::DefaultMixer<T>>) {
-      Array<T> values(this->evaluated_points_size());
+      Array<T> values(this->evaluated_points_num());
       interpolate_to_evaluated_impl<T>(basis_cache, this->order(), src.typed<T>(), values);
       new_varray = VArray<T>::ForContainer(std::move(values));
     }
@@ -383,8 +383,8 @@ Span<float3> NURBSpline::evaluated_positions() const
     return evaluated_position_cache_;
   }
 
-  const int eval_size = this->evaluated_points_size();
-  evaluated_position_cache_.resize(eval_size);
+  const int eval_num = this->evaluated_points_num();
+  evaluated_position_cache_.resize(eval_num);
 
   /* TODO: Avoid copying the evaluated data from the temporary array. */
   VArray<float3> evaluated = Spline::interpolate_to_evaluated(positions_.as_span());
diff --git a/source/blender/blenkernel/intern/spline_poly.cc b/source/blender/blenkernel/intern/spline_poly.cc
index 122f7f6c059..c3cc268c81c 100644
--- a/source/blender/blenkernel/intern/spline_poly.cc
+++ b/source/blender/blenkernel/intern/spline_poly.cc
@@ -76,7 +76,7 @@ void PolySpline::mark_cache_invalid()
   length_cache_dirty_ = true;
 }
 
-int PolySpline::evaluated_points_size() const
+int PolySpline::evaluated_points_num() const
 {
   return this->size();
 }
diff --git a/source/blender/blenlib/BLI_length_parameterize.hh b/source/blender/blenlib/BLI_length_parameterize.hh
index 6fe1c6513a2..f13641c3a65 100644
--- a/source/blender/blenlib/BLI_length_parameterize.hh
+++ b/source/blender/blenlib/BLI_length_parameterize.hh
@@ -17,7 +17,7 @@ namespace blender::length_parameterize {
  * Return the size of the necessary lengths array for a group of points, taking into account the
  * possible last cyclic segment.
  *
- * \note This is the same as #bke::curves::curve_segment_size.
+ * \note This is the same as #bke::curves::curve_segment_num.
  */
 inline int lengths_num(const int points_num, const bool cyclic)
 {
diff --git a/source/blender/draw/intern/draw_cache_impl_curve.cc b/source/blender/draw/intern/draw_cache_impl_curve.cc
index 7b8f34b999c..ebcdabe4942 100644
--- a/source/blender/draw/intern/draw_cache_impl_curve.cc
+++ b/source/blender/draw/intern/draw_cache_impl_curve.cc
@@ -108,7 +108,7 @@ static void curve_eval_render_wire_verts_edges_len_get(const blender::bke::Curve
   const blender::VArray<bool> cyclic = curves.cyclic();
   for (const int i : curves.curves_range()) {
     const IndexRange points = curves.evaluated_points_for_curve(i);
-    *r_edge_len += blender::bke::curves::curve_segment_size(points.size(), cyclic[i]);
+    *r_edge_len += blender::bke::curves::curve_segment_num(points.size(), cyclic[i]);
   }
 }
 
diff --git a/source/blender/editors/space_node/node_draw.cc b/source/blender/editors/space_node/node_draw.cc
index 9076b17a926..f5048e0cc67 100644
--- a/source/blender/editors/space_node/node_draw.cc
+++ b/source/blender/editors/space_node/node_draw.cc
@@ -895,9 +895,9 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         BLI_snprintf(line,
                      sizeof(line),
                      TIP_("\u2022 Mesh: %s vertices, %s edges, %s faces"),
-                     to_string(mesh_info.tot_verts).c_str(),
-                     to_string(mesh_info.tot_edges).c_str(),
-                     to_string(mesh_info.tot_faces).c_str());
+                     to_string(mesh_info.verts_num).c_str(),
+                     to_string(mesh_info.edges_num).c_str(),
+                     to_string(mesh_info.faces_num).c_str());
         ss << line << line_end;
         break;
       }
@@ -908,7 +908,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         BLI_snprintf(line,
                      sizeof(line),
                      TIP_("\u2022 Point Cloud: %s points"),
-                     to_string(pointcloud_info.tot_points).c_str());
+                     to_string(pointcloud_info.points_num).c_str());
         ss << line << line_end;
         break;
       }
@@ -918,7 +918,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         BLI_snprintf(line,
                      sizeof(line),
                      TIP_("\u2022 Curve: %s splines"),
-                     to_string(curve_info.tot_splines).c_str());
+                     to_string(curve_info.splines_num).c_str());
         ss << line << line_end;
         break;
       }
@@ -928,7 +928,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         BLI_snprintf(line,
                      sizeof(line),
                      TIP_("\u2022 Instances: %s"),
-                     to_string(instances_info.tot_instances).c_str());
+                     to_string(instances_info.instances_num).c_str());
         ss << line << line_end;
         break;
       }
diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
index 4afa70d9ef6..66eced27b32 100644
--- a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
+++ b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
@@ -64,7 +64,7 @@ std::unique_ptr<ColumnValues> ExtraColumns::get_column_values(
 void GeometryDataSource::foreach_default_column_ids(
     FunctionRef<void(const SpreadsheetColumnID &, bool is_extra)> fn) const
 {
-  if (component_->attribute_domain_size(domain_) == 0) {
+  if (component_->attribute_domain_num(domain_) == 0) {
     return;
   }
 
@@ -110,8 +110,8 @@ void GeometryDataSource::foreach_default_column_ids(
 std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
     const SpreadsheetColumnID &column_id) const
 {
-  const int domain_size = component_->attribute_domain_size(domain_);
-  if (domain_size == 0) {
+  const int domain_num = component_->attribute_domain_num(domain_);
+  if (domain_num == 0) {
     return {};
   }
 
@@ -129,7 +129,7 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
       Span<InstanceReference> references = instances.references();
       return std::make_unique<ColumnValues>(
           column_id.name,
-          VArray<InstanceReference>::ForFunc(domain_size,
+          VArray<InstanceReference>::ForFunc(domain_num,
                                              [reference_handles, references](int64_t index) {
                                                return references[reference_handles[index]];
                                              }));
@@ -137,13 +137,13 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
     Span<float4x4> transforms = instances.instance_transforms();
     if (STREQ(column_id.name, "Rotation")) {
       return std::make_unique<ColumnValues>(
-          column_id.name, VArray<float3>::ForFunc(domain_size, [transforms](int64_t index) {
+          column_id.name, VArray<float3>::ForFunc(domain_num, [transforms](int64_t index) {
             return transforms[index].to_euler();
           }));
     }
     if (STREQ(column_id.name, "Scale")) {
       return std::make_unique<ColumnValues>(
-          column_id.name, VArray<float3>::ForFunc(domain_size, [transforms](int64_t index) {
+          column_id.name, VArray<float3>::ForFunc(domain_num, [transforms](int64_t index) {
             return transforms[index].scale();
           }));
     }
@@ -210,7 +210,7 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
 
 int GeometryDataSource::tot_rows() const
 {
-  return component_->attribute_domain_size(domain_);
+  return component_->attribute_domain_num(domain_);
 }
 
 /**
@@ -524,17 +524,17 @@ static void add_fields_as_extra_columns(SpaceSpreadsheet *sspreadsheet,
           std::make_unique<GeometryComponentCacheKey>(component));
 
   const AttributeDomain domain = (AttributeDomain)sspreadsheet->attribute_domain;
-  const int domain_size = component.attribute_domain_size(domain);
+  const int domain_num = component.attribute_domain_num(domain);
   for (const auto item : fields_to_show.items()) {
     StringRef name = item.key;
     const GField &field = item.value;
 
     /* Use the cached evaluated array if it exists, otherwise evaluate the field now. */
     GArray<> &evaluated_array = cache.arrays.lookup_or_add_cb({domain, field}, [&]() {
-      GArray<> evaluated_array(field.cpp_type(), domain_size);
+      GArray<> evaluated_array(field.cpp_type(), domain_num);
 
       bke::GeometryComponentFieldContext field_context{component, domain};
-      fn::FieldEvaluator field_evaluator{field_context, domain_size};
+      fn::FieldEvaluator field_evaluator{field_context, domain_num};
       field_evaluator.add_with_destination(field, evaluated_array);
       field_evaluator.evaluate();
       return evaluated_array;
diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc b/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
index c4b5228758c..b009b6b6e4d 100644
--- a/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
+++ b/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
@@ -194,7 +194,7 @@ std::optional<int> GeometryDataSetTreeViewItem::count() const
   }
 
   if (const GeometryComponent *component = geometry.get_component_for_read(component_type_)) {
-    return component->attribute_domain_size(*domain_);
+    return component->attribute_domain_num(*domain_);
   }
 
   return 0;
diff --git a/source/blender/geometry/intern/realize_instances.cc b/source/blender/geometry/intern/realize_instances.cc
index 674271e5444..ae07e817c67 100644
--- a/source/blender/geometry/intern/realize_instances.cc
+++ b/source/blender/geometry/intern/realize_instances.cc
@@ -374,7 +374,7 @@ static Vector<std::pair<int, GSpan>> prepare_attribute_fallbacks(
           }
           /* Convert the attribute on the instances component to the expected attribute type. */
           std::unique_ptr<GArray<>> temporary_array = std::make_unique<GArray<>>(
-              to_type, instances_component.instances_amount());
+              to_type, instances_component.instances_num());
           conversions.convert_to_initialized_n(span, temporary_array->as_mutable_span());
           span = temporary_array->as_span();
           gather_info.r_temporary_arrays.append(std::move(temporary_array));
@@ -1215,13 +1215,13 @@ static void execute_realize_curve_tasks(const RealizeInstancesOptions &options,
 
   const RealizeCurveTask &last_task = tasks.last();
   const Curves &last_curves = *last_task.curve_info->curves;
-  const int points_size = last_task.start_indices.point + last_curves.geometry.point_num;
-  const int curves_size = last_task.start_indices.curve + last_curves.geometry.curve_num;
+  const int points_num = last_task.start_indices.point + last_curves.geometry.point_num;
+  const int curves_num = last_task.start_indices.curve + last_curves.geometry.curve_num;
 
   /* Allocate new curves data-block. */
-  Curves *dst_curves_id = bke::curves_new_nomain(points_size, curves_size);
+  Curves *dst_curves_id = bke::curves_new_nomain(points_num, curves_num);
   bke::CurvesGeometry &dst_curves = bke::CurvesGeometry::wrap(dst_curves_id->geometry);
-  dst_curves.offsets_for_write().last() = points_size;
+  dst_curves.offsets_for_write().last() = points_num;
   CurveComponent &dst_component = r_realized_geometry.get_component_for_write<CurveComponent>();
   dst_component.replace(dst_curves_id);
 
diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc
index 9433151411e..cdf16d813f3 100644
--- a/source/blender/modifiers/intern/MOD_nodes.cc
+++ b/source/blender/modifiers/intern/MOD_nodes.cc
@@ -985,17 +985,16 @@ static Vector<OutputAttributeToStore> compute_attributes_to_store(
       if (!component.attribute_domain_supported(domain)) {
         continue;
       }
-      const int domain_size = component.attribute_domain_size(domain);
+      const int domain_num = component.attribute_domain_num(domain);
       blender::bke::GeometryComponentFieldContext field_context{component, domain};
-      blender::fn::FieldEvaluator field_evaluator{field_context, domain_size};
+      blender::fn::FieldEvaluator field_evaluator{field_context, domain_num};
       for (const OutputAttributeInfo &output_info : outputs_info) {
         const CPPType &type = output_info.field.cpp_type();
         OutputAttributeToStore store{
             component_type,
             domain,
             output_info.name,
-            GMutableSpan{
-                type, MEM_malloc_arrayN(domain_size, type.size(), __func__), domain_size}};
+            GMutableSpan{type, MEM_malloc_arrayN(domain_num, type.size(), __func__), domain_num}};
         field_evaluator.add_with_destination(output_info.field, store.data);
         attributes_to_store.append(store);
       }
diff --git a/source/blender/nodes/NOD_geometry_nodes_eval_log.hh b/source/blender/nodes/NOD_geometry_nodes_eval_log.hh
index 1ad859aa47b..4fbf5192222 100644
--- a/source/blender/nodes/NOD_geometry_nodes_eval_log.hh
+++ b/source/blender/nodes/NOD_geometry_nodes_eval_log.hh
@@ -103,16 +103,16 @@ class GeometryValueLog : public ValueLog {
 
  public:
   struct MeshInfo {
-    int tot_verts, tot_edges, tot_faces;
+    int verts_num, edges_num, faces_num;
   };
   struct CurveInfo {
-    int tot_splines;
+    int splines_num;
   };
   struct PointCloudInfo {
-    int tot_points;
+    int points_num;
   };
   struct InstancesInfo {
-    int tot_instances;
+    int instances_num;
   };
 
   std::optional<MeshInfo> mesh_info;
diff --git a/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc b/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc
index ea26eec0c15..b29831ceeb6 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc
@@ -217,16 +217,16 @@ template<typename T> class AccumulateFieldInput final : public GeometryFieldInpu
                                  IndexMask UNUSED(mask)) const final
   {
     const GeometryComponentFieldContext field_context{component, source_domain_};
-    const int domain_size = component.attribute_domain_size(field_context.domain());
+    const int domain_num = component.attribute_domain_num(field_context.domain());
 
-    fn::FieldEvaluator evaluator{field_context, domain_size};
+    fn::FieldEvaluator evaluator{field_context, domain_num};
     evaluator.add(input_);
     evaluator.add(group_index_);
     evaluator.evaluate();
     const VArray<T> &values = evaluator.get_evaluated<T>(0);
     const VArray<int> &group_indices = evaluator.get_evaluated<int>(1);
 
-    Array<T> accumulations_out(domain_size);
+    Array<T> accumulations_out(domain_num);
 
     if (group_indices.is_single()) {
       T accumulation = T();
@@ -303,9 +303,9 @@ template<typename T> class TotalFieldInput final : public GeometryFieldInput {
                                  IndexMask UNUSED(mask)) const final
   {
     const GeometryComponentFieldContext field_context{component, source_domain_};
-    const int domain_size = component.attribute_domain_size(field_context.domain());
+    const int domain_num = component.attribute_domain_num(field_context.domain());
 
-    fn::FieldEvaluator evaluator{field_context, domain_size};
+    fn::FieldEvaluator evaluator{field_context, domain_num};
     evaluator.add(input_);
     evaluator.add(group_index_);
     evaluator.evaluate();
@@ -317,10 +317,10 @@ template<typename T> class TotalFieldInput final : public GeometryFieldInput {
       for (const int i : values.index_range()) {
         accumulation = values[i] + accumulation;
       }
-      return VArray<T>::ForSingle(accumulation, domain_size);
+      return VArray<T>::ForSingle(accumulation, domain_num);
     }
 
-    Array<T> accumulations_out(domain_size);
+    Array<T> accumulations_out(domain_num);
     Map<int, T> accumulations;
     for (const int i : values.index_range()) {
       T &value = accumulations.lookup_or_add_default(group_indices[i]);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
index 45a6aabeb03..18cf005c965 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
@@ -112,8 +112,8 @@ static void try_capture_field_on_geometry(GeometryComponent &component,
                                           const GField &field)
 {
   GeometryComponentFieldContext field_context{component, domain};
-  const int domain_size = component.attribute_domain_size(domain);
-  const IndexMask mask{IndexMask(domain_size)};
+  const int domain_num = component.attribute_domain_num(domain);
+  const IndexMask mask{IndexMask(domain_num)};
 
   const CustomDataType data_type = bke::cpp_type_to_custom_data_type(field.cpp_type());
   OutputAttribute output_attribute = component.attribute_try_get_for_output_only(
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc
index b3fe9d160b3..8ab0eb678e7 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc
@@ -72,11 +72,11 @@ static void node_geo_exec(GeoNodeExecParams params)
     case GEO_COMPONENT_TYPE_MESH: {
       if (geometry_set.has_mesh()) {
         const MeshComponent *component = geometry_set.get_component_for_read<MeshComponent>();
-        params.set_output("Point Count", component->attribute_domain_size(ATTR_DOMAIN_POINT));
-        params.set_output("Edge Count", component->attribute_domain_size(ATTR_DOMAIN_EDGE));
-        params.set_output("Face Count", component->attribute_domain_size(ATTR_DOMAIN_FACE));
+        params.set_output("Point Count", component->attribute_domain_num(ATTR_DOMAIN_POINT));
+        params.set_output("Edge Count", component->attribute_domain_num(ATTR_DOMAIN_EDGE));
+        params.set_output("Face Count", component->attribute_domain_num(ATTR_DOMAIN_FACE));
         params.set_output("Face Corner Count",
-                          component->attribute_domain_size(ATTR_DOMAIN_CORNER));
+                          component->attribute_domain_num(ATTR_DOMAIN_CORNER));
       }
       else {
         params.set_default_remaining_outputs();
@@ -86,8 +86,8 @@ static void node_geo_exec(GeoNodeExecParams params)
     case GEO_COMPONENT_TYPE_CURVE: {
       if (geometry_set.has_curves()) {
         const CurveComponent *component = geometry_set.get_component_for_read<CurveComponent>();
-        params.set_output("Point Count", component->attribute_domain_size(ATTR_DOMAIN_POINT));
-        params.set_output("Spline Count", component->attribute_domain_size(ATTR_DOMAIN_CURVE));
+        params.set_output("Point Count", component->attribute_domain_num(ATTR_DOMAIN_POINT));
+        params.set_output("Spline Count", component->attribute_domain_num(ATTR_DOMAIN_CURVE));
       }
       else {
         params.set_default_remaining_outputs();
@@ -98,7 +98,7 @@ static void node_geo_exec(GeoNodeExecParams params)
       if (geometry_set.has_pointcloud()) {
         const PointCloudComponent *component =
             geometry_set.get_component_for_read<PointCloudComponent>();
-        params.set_output("Point Count", component->attribute_domain_size(ATTR_DOMAIN_POINT));
+        params.set_output("Point Count", component->attribute_domain_num(ATTR_DOMAIN_POINT));
       }
       else {
         params.set_default_remaining_outputs();
@@ -109,8 +109,7 @@ static void node_geo_exec(GeoNodeExecParams params)
       if (geometry_set.has_instances()) {
         const InstancesComponent *component =
             geometry_set.get_component_for_read<InstancesComponent>();
-        params.set_output("Instance Count",
-                          component->attribute_domain_size(ATTR_DOMAIN_INSTANCE));
+        params.set_output("Instance Count", component->attribute_domain_num(ATTR_DOMAIN_INSTANCE));
       }
       else {
         params.set_default_remaining_outputs();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
index 1153f18ffd4..c7f65a68d60 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
@@ -197,9 +197,9 @@ static void node_geo_exec(GeoNodeExecParams params)
       for (const GeometryComponent *component : components) {
         if (component->attribute_domain_supported(domain)) {
           GeometryComponentFieldContext field_context{*component, domain};
-          const int domain_size = component->attribute_domain_size(domain);
+          const int domain_num = component->attribute_domain_num(domain);
 
-          fn::FieldEvaluator data_evaluator{field_context, domain_size};
+          fn::FieldEvaluator data_evaluator{field_context, domain_num};
           data_evaluator.add(input_field);
           data_evaluator.set_selection(selection_field);
           data_evaluator.evaluate();
@@ -275,9 +275,9 @@ static void node_geo_exec(GeoNodeExecParams params)
       for (const GeometryComponent *component : components) {
         if (component->attribute_domain_supported(domain)) {
           GeometryComponentFieldContext field_context{*component, domain};
-          const int domain_size = component->attribute_domain_size(domain);
+          const int domain_num = component->attribute_domain_num(domain);
 
-          fn::FieldEvaluator data_evaluator{field_context, domain_size};
+          fn::FieldEvaluator data_evaluator{field_context, domain_num};
           data_evaluator.add(input_field);
           data_evaluator.set_selection(selection_field);
           data_evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
index 09d0f13c50d..31f706c497c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
@@ -138,14 +138,14 @@ static Mesh *compute_hull(const GeometrySet &geometry_set)
 {
   int span_count = 0;
   int count = 0;
-  int total_size = 0;
+  int total_num = 0;
 
   Span<float3> positions_span;
 
   if (geometry_set.has_mesh()) {
     count++;
     const MeshComponent *component = geometry_set.get_component_for_read<MeshComponent>();
-    total_size += component->attribute_domain_size(ATTR_DOMAIN_POINT);
+    total_num += component->attribute_domain_num(ATTR_DOMAIN_POINT);
   }
 
   if (geometry_set.has_pointcloud()) {
@@ -155,7 +155,7 @@ static Mesh *compute_hull(const GeometrySet &geometry_set)
         geometry_set.get_component_for_read<PointCloudComponent>();
     VArray<float3> varray = component->attribute_get_for_read<float3>(
         "position", ATTR_DOMAIN_POINT, {0, 0, 0});
-    total_size += varray.size();
+    total_num += varray.size();
     positions_span = varray.get_internal_span();
   }
 
@@ -165,7 +165,7 @@ static Mesh *compute_hull(const GeometrySet &geometry_set)
     const Curves &curves_id = *geometry_set.get_curves_for_read();
     const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
     positions_span = curves.evaluated_positions();
-    total_size += positions_span.size();
+    total_num += positions_span.size();
   }
 
   if (count == 0) {
@@ -178,7 +178,7 @@ static Mesh *compute_hull(const GeometrySet &geometry_set)
     return hull_from_bullet(nullptr, positions_span);
   }
 
-  Array<float3> positions(total_size);
+  Array<float3> positions(total_num);
   int offset = 0;
 
   if (geometry_set.has_mesh()) {
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
index 95ea978541c..fb8a488ddae 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
@@ -106,13 +106,13 @@ static float3 get_center(const float3 vec_pos2prev, const FilletData &fd, const
 /* Calculate the direction vectors from each vertex to their previous vertex. */
 static Array<float3> calculate_directions(const Span<float3> positions)
 {
-  const int size = positions.size();
-  Array<float3> directions(size);
+  const int num = positions.size();
+  Array<float3> directions(num);
 
-  for (const int i : IndexRange(size - 1)) {
+  for (const int i : IndexRange(num - 1)) {
     directions[i] = math::normalize(positions[i + 1] - positions[i]);
   }
-  directions[size - 1] = math::normalize(positions[0] - positions[size - 1]);
+  directions[num - 1] = math::normalize(positions[0] - positions[num - 1]);
 
   return directions;
 }
@@ -120,11 +120,11 @@ static Array<float3> calculate_directions(const Span<float3> positions)
 /* Calculate the axes around which the fillet is built. */
 static Array<float3> calculate_axes(const Span<float3> directions)
 {
-  const int size = directions.size();
-  Array<float3> axes(size);
+  const int num = directions.size();
+  Array<float3> axes(num);
 
-  axes[0] = math::normalize(math::cross(-directions[size - 1], directions[0]));
-  for (const int i : IndexRange(1, size - 1)) {
+  axes[0] = math::normalize(math::cross(-directions[num - 1], directions[0]));
+  for (const int i : IndexRange(1, num - 1)) {
     axes[i] = math::normalize(math::cross(-directions[i - 1], directions[i]));
   }
 
@@ -134,11 +134,11 @@ static Array<float3> calculate_axes(const Span<float3> directions)
 /* Calculate the angle of the arc formed by the fillet. */
 static Array<float> calculate_angles(const Span<float3> directions)
 {
-  const int size = directions.size();
-  Array<float> angles(size);
+  const int num = directions.size();
+  Array<float> angles(num);
 
-  angles[0] = M_PI - angle_v3v3(-directions[size - 1], directions[0]);
-  for (const int i : IndexRange(1, size - 1)) {
+  angles[0] = M_PI - angle_v3v3(-directions[num - 1], directions[0]);
+  for (const int i : IndexRange(1, num - 1)) {
     angles[i] = M_PI - angle_v3v3(-directions[i - 1], directions[i]);
   }
 
@@ -147,18 +147,18 @@ static Array<float> calculate_angles(const Span<float3> directions)
 
 /* Calculate the segment count in each filleted arc. */
 static Array<int> calculate_counts(const FilletParam &fillet_param,
-                                   const int size,
+                                   const int num,
                                    const int spline_offset,
                                    const bool cyclic)
 {
-  Array<int> counts(size, 1);
+  Array<int> counts(num, 1);
   if (fillet_param.mode == GEO_NODE_CURVE_FILLET_POLY) {
-    for (const int i : IndexRange(size)) {
+    for (const int i : IndexRange(num)) {
       counts[i] = fillet_param.counts[spline_offset + i];
     }
   }
   if (!cyclic) {
-    counts[0] = counts[size - 1] = 0;
+    counts[0] = counts[num - 1] = 0;
   }
 
   return counts;
@@ -166,17 +166,17 @@ static Array<int> calculate_counts(const FilletParam &fillet_param,
 
 /* Calculate the radii for the vertices to be filleted. */
 static Array<float> calculate_radii(const FilletParam &fillet_param,
-                                    const int size,
+                                    const int num,
                                     const int spline_offset)
 {
-  Array<float> radii(size, 0.0f);
+  Array<float> radii(num, 0.0f);
   if (fillet_param.limit_radius) {
-    for (const int i : IndexRange(size)) {
+    for (const int i : IndexRange(num)) {
       radii[i] = std::max(fillet_param.radii[spline_offset + i], 0.0f);
     }
   }
   else {
-    for (const int i : IndexRange(size)) {
+    for (const int i : IndexRange(num)) {
       radii[i] = fillet_param.radii[spline_offset + i];
     }
   }
@@ -207,15 +207,15 @@ static FilletData calculate_fillet_data(const Spline &spline,
                                         MutableSpan<int> point_counts,
                                         const int spline_offset)
 {
-  const int size = spline.size();
+  const int num = spline.size();
 
   FilletData fd;
   fd.directions = calculate_directions(spline.positions());
   fd.positions = spline.positions();
   fd.axes = calculate_axes(fd.directions);
   fd.angles = calculate_angles(fd.directions);
-  fd.counts = calculate_counts(fillet_param, size, spline_offset, spline.is_cyclic());
-  fd.radii = calculate_radii(fillet_param, size, spline_offset);
+  fd.counts = calculate_counts(fillet_param, num, spline_offset, spline.is_cyclic());
+  fd.radii = calculate_radii(fillet_param, num, spline_offset);
 
   added_count = calculate_point_counts(point_counts, fd.radii, fd.counts);
 
@@ -229,19 +229,19 @@ static void limit_radii(FilletData &fd, const bool cyclic)
   Span<float> angles(fd.angles);
   Span<float3> positions(fd.positions);
 
-  const int size = radii.size();
-  const int fillet_count = cyclic ? size : size - 2;
+  const int num = radii.size();
+  const int fillet_count = cyclic ? num : num - 2;
   const int start = cyclic ? 0 : 1;
-  Array<float> max_radii(size, FLT_MAX);
+  Array<float> max_radii(num, FLT_MAX);
 
   if (cyclic) {
     /* Calculate lengths between adjacent control points. */
-    const float len_prev = math::distance(positions[0], positions[size - 1]);
+    const float len_prev = math::distance(positions[0], positions[num - 1]);
     const float len_next = math::distance(positions[0], positions[1]);
 
     /* Calculate tangent lengths of fillets in control points. */
     const float tan_len = radii[0] * tan(angles[0] / 2.0f);
-    const float tan_len_prev = radii[size - 1] * tan(angles[size - 1] / 2.0f);
+    const float tan_len_prev = radii[num - 1] * tan(angles[num - 1] / 2.0f);
     const float tan_len_next = radii[1] * tan(angles[1] / 2.0f);
 
     float factor_prev = 1.0f, factor_next = 1.0f;
@@ -255,12 +255,12 @@ static void limit_radii(FilletData &fd, const bool cyclic)
     /* Scale max radii by calculated factors. */
     max_radii[0] = radii[0] * std::min(factor_next, factor_prev);
     max_radii[1] = radii[1] * factor_next;
-    max_radii[size - 1] = radii[size - 1] * factor_prev;
+    max_radii[num - 1] = radii[num - 1] * factor_prev;
   }
 
   /* Initialize max_radii to largest possible radii. */
   float prev_dist = math::distance(positions[1], positions[0]);
-  for (const int i : IndexRange(1, size - 2)) {
+  for (const int i : IndexRange(1, num - 2)) {
     const float temp_dist = math::distance(positions[i], positions[i + 1]);
     max_radii[i] = std::min(prev_dist, temp_dist) / tan(angles[i] / 2.0f);
     prev_dist = temp_dist;
@@ -282,7 +282,7 @@ static void limit_radii(FilletData &fd, const bool cyclic)
   }
 
   /* Assign the max_radii to the fillet data's radii. */
-  for (const int i : IndexRange(size)) {
+  for (const int i : IndexRange(num)) {
     radii[i] = std::min(radii[i], max_radii[i]);
   }
 }
@@ -358,10 +358,10 @@ static void update_bezier_positions(const FilletData &fd,
   Span<float3> positions(fd.positions);
   Span<float3> directions(fd.directions);
 
-  const int size = radii.size();
+  const int num = radii.size();
 
   int i_dst = 0;
-  for (const int i_src : IndexRange(size)) {
+  for (const int i_src : IndexRange(num)) {
     const int count = point_counts[i_src];
 
     /* Skip if the point count for the vertex is 1. */
@@ -385,7 +385,7 @@ static void update_bezier_positions(const FilletData &fd,
 
     /* Position the end points of the arc and their handles. */
     const int end_i = i_dst + count - 1;
-    const float3 prev_dir = i_src == 0 ? -directions[size - 1] : -directions[i_src - 1];
+    const float3 prev_dir = i_src == 0 ? -directions[num - 1] : -directions[i_src - 1];
     const float3 next_dir = directions[i_src];
     dst_spline.positions()[i_dst] = positions[i_src] + displacement * prev_dir;
     dst_spline.positions()[end_i] = positions[i_src] + displacement * next_dir;
@@ -442,10 +442,10 @@ static void update_poly_positions(const FilletData &fd,
   Span<float3> positions(fd.positions);
   Span<float3> directions(fd.directions);
 
-  const int size = radii.size();
+  const int num = radii.size();
 
   int i_dst = 0;
-  for (const int i_src : IndexRange(size)) {
+  for (const int i_src : IndexRange(num)) {
     const int count = point_counts[i_src];
 
     /* Skip if the point count for the vertex is 1. */
@@ -460,7 +460,7 @@ static void update_poly_positions(const FilletData &fd,
 
     /* Position the end points of the arc. */
     const int end_i = i_dst + count - 1;
-    const float3 prev_dir = i_src == 0 ? -directions[size - 1] : -directions[i_src - 1];
+    const float3 prev_dir = i_src == 0 ? -directions[num - 1] : -directions[i_src - 1];
     const float3 next_dir = directions[i_src];
     dst_spline.positions()[i_dst] = positions[i_src] + displacement * prev_dir;
     dst_spline.positions()[end_i] = positions[i_src] + displacement * next_dir;
@@ -487,15 +487,15 @@ static SplinePtr fillet_spline(const Spline &spline,
                                const FilletParam &fillet_param,
                                const int spline_offset)
 {
-  const int size = spline.size();
+  const int num = spline.size();
   const bool cyclic = spline.is_cyclic();
 
-  if (size < 3) {
+  if (num < 3) {
     return spline.copy();
   }
 
   /* Initialize the point_counts with 1s (at least one vertex on dst for each vertex on src). */
-  Array<int> point_counts(size, 1);
+  Array<int> point_counts(num, 1);
 
   int added_count = 0;
   /* Update point_counts array and added_count. */
@@ -505,7 +505,7 @@ static SplinePtr fillet_spline(const Spline &spline,
     limit_radii(fd, cyclic);
   }
 
-  const int total_points = added_count + size;
+  const int total_points = added_count + num;
   const Array<int> dst_to_src = create_dst_to_src_map(point_counts, total_points);
   SplinePtr dst_spline_ptr = spline.copy_only_settings();
   (*dst_spline_ptr).resize(total_points);
@@ -581,8 +581,8 @@ static void calculate_curve_fillet(GeometrySet &geometry_set,
 
   CurveComponent &component = geometry_set.get_component_for_write<CurveComponent>();
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  fn::FieldEvaluator field_evaluator{field_context, domain_size};
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  fn::FieldEvaluator field_evaluator{field_context, domain_num};
 
   field_evaluator.add(radius_field);
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
index de29735bd2d..64a174df599 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
@@ -27,9 +27,9 @@ static void node_geo_exec(GeoNodeExecParams params)
     Field<bool> selection_field = params.get_input<Field<bool>>("Selection");
     const CurveComponent &component = *geometry_set.get_component_for_read<CurveComponent>();
     GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_CURVE};
-    const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_CURVE);
+    const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_CURVE);
 
-    fn::FieldEvaluator selection_evaluator{field_context, domain_size};
+    fn::FieldEvaluator selection_evaluator{field_context, domain_num};
     selection_evaluator.add(selection_field);
     selection_evaluator.evaluate();
     const IndexMask selection = selection_evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
index 6e45411a9af..500804e41f0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
@@ -107,20 +107,20 @@ static void copy_attributes(const Spline &input_spline, Spline &output_spline, C
 static Vector<float3> create_nurbs_to_bezier_handles(const Span<float3> nurbs_positions,
                                                      const KnotsMode knots_mode)
 {
-  const int nurbs_positions_size = nurbs_positions.size();
+  const int nurbs_positions_num = nurbs_positions.size();
   Vector<float3> handle_positions;
   if (knots_mode == NURBS_KNOT_MODE_BEZIER) {
-    for (const int i : IndexRange(nurbs_positions_size)) {
+    for (const int i : IndexRange(nurbs_positions_num)) {
       if (i % 3 == 1) {
         continue;
       }
       handle_positions.append(nurbs_positions[i]);
     }
-    if (nurbs_positions_size % 3 == 1) {
+    if (nurbs_positions_num % 3 == 1) {
       handle_positions.pop_last();
     }
-    else if (nurbs_positions_size % 3 == 2) {
-      const int last_index = nurbs_positions_size - 1;
+    else if (nurbs_positions_num % 3 == 2) {
+      const int last_index = nurbs_positions_num - 1;
       handle_positions.append(2 * nurbs_positions[last_index] - nurbs_positions[last_index - 1]);
     }
   }
@@ -134,11 +134,11 @@ static Vector<float3> create_nurbs_to_bezier_handles(const Span<float3> nurbs_po
       handle_positions.append(2 * nurbs_positions[0] - nurbs_positions[1]);
       handle_positions.append(nurbs_positions[1]);
     }
-    const int segments_size = nurbs_positions_size - 1;
-    const bool ignore_interior_segment = segments_size == 3 && is_periodic == false;
+    const int segments_num = nurbs_positions_num - 1;
+    const bool ignore_interior_segment = segments_num == 3 && is_periodic == false;
     if (ignore_interior_segment == false) {
-      const float mid_offset = (float)(segments_size - 1) / 2.0f;
-      for (const int i : IndexRange(1, segments_size - 2)) {
+      const float mid_offset = (float)(segments_num - 1) / 2.0f;
+      for (const int i : IndexRange(1, segments_num - 2)) {
         const int divisor = is_periodic ?
                                 3 :
                                 std::min(3, (int)(-std::abs(i - mid_offset) + mid_offset + 1.0f));
@@ -151,7 +151,7 @@ static Vector<float3> create_nurbs_to_bezier_handles(const Span<float3> nurbs_po
         }
       }
     }
-    const int last_index = nurbs_positions_size - 1;
+    const int last_index = nurbs_positions_num - 1;
     if (is_periodic) {
       handle_positions.append(
           nurbs_positions[last_index - 1] +
@@ -368,11 +368,11 @@ static void node_geo_exec(GeoNodeExecParams params)
     const std::unique_ptr<CurveEval> curve = curves_to_curve_eval(
         *curve_component->get_for_read());
     GeometryComponentFieldContext field_context{*curve_component, ATTR_DOMAIN_CURVE};
-    const int domain_size = curve_component->attribute_domain_size(ATTR_DOMAIN_CURVE);
+    const int domain_num = curve_component->attribute_domain_num(ATTR_DOMAIN_CURVE);
 
     Span<SplinePtr> src_splines = curve->splines();
 
-    fn::FieldEvaluator selection_evaluator{field_context, domain_size};
+    fn::FieldEvaluator selection_evaluator{field_context, domain_num};
     selection_evaluator.add(selection_field);
     selection_evaluator.evaluate();
     const VArray<bool> &selection = selection_evaluator.get_evaluated<bool>(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
index 371556c04f1..4d8745bf79e 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
@@ -30,9 +30,9 @@ static Array<int> get_subdivided_offsets(const Spline &spline,
                                          const VArray<int> &cuts,
                                          const int spline_offset)
 {
-  Array<int> offsets(spline.segments_size() + 1);
+  Array<int> offsets(spline.segments_num() + 1);
   int offset = 0;
-  for (const int i : IndexRange(spline.segments_size())) {
+  for (const int i : IndexRange(spline.segments_num())) {
     offsets[i] = offset;
     offset = offset + std::max(cuts[spline_offset + i], 0) + 1;
   }
@@ -46,8 +46,8 @@ static void subdivide_attribute(Span<T> src,
                                 const bool is_cyclic,
                                 MutableSpan<T> dst)
 {
-  const int src_size = src.size();
-  threading::parallel_for(IndexRange(src_size - 1), 1024, [&](IndexRange range) {
+  const int src_num = src.size();
+  threading::parallel_for(IndexRange(src_num - 1), 1024, [&](IndexRange range) {
     for (const int i : range) {
       const int cuts = offsets[i + 1] - offsets[i];
       dst[offsets[i]] = src[i];
@@ -60,7 +60,7 @@ static void subdivide_attribute(Span<T> src,
   });
 
   if (is_cyclic) {
-    const int i = src_size - 1;
+    const int i = src_num - 1;
     const int cuts = offsets[i + 1] - offsets[i];
     dst[offsets[i]] = src.last();
     const float factor_delta = cuts == 0 ? 1.0f : 1.0f / cuts;
@@ -86,7 +86,7 @@ static void subdivide_attribute(Span<T> src,
 static void subdivide_bezier_segment(const BezierSpline &src,
                                      const int index,
                                      const int offset,
-                                     const int result_size,
+                                     const int result_num,
                                      Span<float3> src_positions,
                                      Span<float3> src_handles_left,
                                      Span<float3> src_handles_right,
@@ -106,11 +106,11 @@ static void subdivide_bezier_segment(const BezierSpline &src,
     if (is_last_cyclic_segment) {
       dst_type_left.first() = BEZIER_HANDLE_VECTOR;
     }
-    dst_type_left.slice(offset + 1, result_size).fill(BEZIER_HANDLE_VECTOR);
-    dst_type_right.slice(offset, result_size).fill(BEZIER_HANDLE_VECTOR);
+    dst_type_left.slice(offset + 1, result_num).fill(BEZIER_HANDLE_VECTOR);
+    dst_type_right.slice(offset, result_num).fill(BEZIER_HANDLE_VECTOR);
 
-    const float factor_delta = 1.0f / result_size;
-    for (const int cut : IndexRange(result_size)) {
+    const float factor_delta = 1.0f / result_num;
+    for (const int cut : IndexRange(result_num)) {
       const float factor = cut * factor_delta;
       dst_positions[offset + cut] = attribute_math::mix2(
           factor, src_positions[index], src_positions[next_index]);
@@ -120,10 +120,10 @@ static void subdivide_bezier_segment(const BezierSpline &src,
     if (is_last_cyclic_segment) {
       dst_type_left.first() = BEZIER_HANDLE_FREE;
     }
-    dst_type_left.slice(offset + 1, result_size).fill(BEZIER_HANDLE_FREE);
-    dst_type_right.slice(offset, result_size).fill(BEZIER_HANDLE_FREE);
+    dst_type_left.slice(offset + 1, result_num).fill(BEZIER_HANDLE_FREE);
+    dst_type_right.slice(offset, result_num).fill(BEZIER_HANDLE_FREE);
 
-    const int i_segment_last = is_last_cyclic_segment ? 0 : offset + result_size;
+    const int i_segment_last = is_last_cyclic_segment ? 0 : offset + result_num;
 
     /* Create a Bezier segment to update iteratively for every subdivision
      * and references to the meaningful values for ease of use. */
@@ -138,8 +138,8 @@ static void subdivide_bezier_segment(const BezierSpline &src,
     handle_prev = src_handles_right[index];
     handle_next = src_handles_left[next_index];
 
-    for (const int cut : IndexRange(result_size - 1)) {
-      const float parameter = 1.0f / (result_size - cut);
+    for (const int cut : IndexRange(result_num - 1)) {
+      const float parameter = 1.0f / (result_num - cut);
       const BezierSpline::InsertResult insert = temp.calculate_segment_insertion(0, 1, parameter);
 
       /* Copy relevant temporary data to the result. */
@@ -154,7 +154,7 @@ static void subdivide_bezier_segment(const BezierSpline &src,
     }
 
     /* Copy the handles for the last segment from the temporary spline. */
-    dst_handles_right[offset + result_size - 1] = handle_prev;
+    dst_handles_right[offset + result_num - 1] = handle_prev;
     dst_handles_left[i_segment_last] = handle_next;
   }
 }
@@ -287,9 +287,9 @@ static SplinePtr subdivide_spline(const Spline &spline,
    * of cuts is a real span (especially considering the note below). Using the offset at each
    * point facilitates subdividing in parallel later. */
   Array<int> offsets = get_subdivided_offsets(spline, cuts, spline_offset);
-  const int result_size = offsets.last() + int(!spline.is_cyclic());
+  const int result_num = offsets.last() + int(!spline.is_cyclic());
   SplinePtr new_spline = spline.copy_only_settings();
-  new_spline->resize(result_size);
+  new_spline->resize(result_num);
   subdivide_builtin_attributes(spline, offsets, *new_spline);
   subdivide_dynamic_attributes(spline, offsets, *new_spline);
   return new_spline;
@@ -334,9 +334,9 @@ static void node_geo_exec(GeoNodeExecParams params)
 
     const CurveComponent &component = *geometry_set.get_component_for_read<CurveComponent>();
     GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-    const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
+    const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
 
-    fn::FieldEvaluator evaluator{field_context, domain_size};
+    fn::FieldEvaluator evaluator{field_context, domain_num};
     evaluator.add(cuts_field);
     evaluator.evaluate();
     const VArray<int> &cuts = evaluator.get_evaluated<int>(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
index 894580f2932..b45a0d6c81a 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
@@ -90,7 +90,7 @@ static Array<int> calculate_spline_point_offsets(GeoNodeExecParams &params,
       int offset = 0;
       for (const int i : IndexRange(size)) {
         offsets[i] = offset;
-        if (splines[i]->evaluated_points_size() > 0) {
+        if (splines[i]->evaluated_points_num() > 0) {
           offset += count;
         }
       }
@@ -104,7 +104,7 @@ static Array<int> calculate_spline_point_offsets(GeoNodeExecParams &params,
       int offset = 0;
       for (const int i : IndexRange(size)) {
         offsets[i] = offset;
-        if (splines[i]->evaluated_points_size() > 0) {
+        if (splines[i]->evaluated_points_num() > 0) {
           offset += splines[i]->length() / resolution + 1;
         }
       }
@@ -240,18 +240,18 @@ static void copy_uniform_sample_point_attributes(const Span<SplinePtr> splines,
     for (const int i : range) {
       const Spline &spline = *splines[i];
       const int offset = offsets[i];
-      const int size = offsets[i + 1] - offsets[i];
-      if (size == 0) {
+      const int num = offsets[i + 1] - offsets[i];
+      if (num == 0) {
         continue;
       }
 
-      const Array<float> uniform_samples = spline.sample_uniform_index_factors(size);
+      const Array<float> uniform_samples = spline.sample_uniform_index_factors(num);
 
       spline.sample_with_index_factors<float3>(
-          spline.evaluated_positions(), uniform_samples, data.positions.slice(offset, size));
+          spline.evaluated_positions(), uniform_samples, data.positions.slice(offset, num));
       spline.sample_with_index_factors<float>(spline.interpolate_to_evaluated(spline.radii()),
                                               uniform_samples,
-                                              data.radii.slice(offset, size));
+                                              data.radii.slice(offset, num));
 
       for (const Map<AttributeIDRef, GMutableSpan>::Item item : data.point_attributes.items()) {
         const AttributeIDRef attribute_id = item.key;
@@ -260,14 +260,13 @@ static void copy_uniform_sample_point_attributes(const Span<SplinePtr> splines,
         BLI_assert(spline.attributes.get_for_read(attribute_id));
         GSpan spline_span = *spline.attributes.get_for_read(attribute_id);
 
-        spline.sample_with_index_factors(spline.interpolate_to_evaluated(spline_span),
-                                         uniform_samples,
-                                         dst.slice(offset, size));
+        spline.sample_with_index_factors(
+            spline.interpolate_to_evaluated(spline_span), uniform_samples, dst.slice(offset, num));
       }
 
       if (!data.tangents.is_empty()) {
         Span<float3> src_tangents = spline.evaluated_tangents();
-        MutableSpan<float3> sampled_tangents = data.tangents.slice(offset, size);
+        MutableSpan<float3> sampled_tangents = data.tangents.slice(offset, num);
         spline.sample_with_index_factors<float3>(src_tangents, uniform_samples, sampled_tangents);
         for (float3 &vector : sampled_tangents) {
           vector = math::normalize(vector);
@@ -276,7 +275,7 @@ static void copy_uniform_sample_point_attributes(const Span<SplinePtr> splines,
 
       if (!data.normals.is_empty()) {
         Span<float3> src_normals = spline.evaluated_normals();
-        MutableSpan<float3> sampled_normals = data.normals.slice(offset, size);
+        MutableSpan<float3> sampled_normals = data.normals.slice(offset, num);
         spline.sample_with_index_factors<float3>(src_normals, uniform_samples, sampled_normals);
         for (float3 &vector : sampled_normals) {
           vector = math::normalize(vector);
@@ -298,8 +297,8 @@ static void copy_spline_domain_attributes(const CurveEval &curve,
 
         for (const int i : curve.splines().index_range()) {
           const int offset = offsets[i];
-          const int size = offsets[i + 1] - offsets[i];
-          type.fill_assign_n(curve_attribute[i], dst[offset], size);
+          const int num = offsets[i + 1] - offsets[i];
+          type.fill_assign_n(curve_attribute[i], dst[offset], num);
         }
 
         return true;
@@ -329,13 +328,13 @@ static void node_geo_exec(GeoNodeExecParams params)
     curve->assert_valid_point_attributes();
 
     const Array<int> offsets = calculate_spline_point_offsets(params, mode, *curve, splines);
-    const int total_size = offsets.last();
-    if (total_size == 0) {
+    const int total_num = offsets.last();
+    if (total_num == 0) {
       geometry_set.keep_only({GEO_COMPONENT_TYPE_INSTANCES});
       return;
     }
 
-    geometry_set.replace_pointcloud(BKE_pointcloud_new_nomain(total_size));
+    geometry_set.replace_pointcloud(BKE_pointcloud_new_nomain(total_num));
     PointCloudComponent &points = geometry_set.get_component_for_write<PointCloudComponent>();
     ResultAttributes point_attributes = create_attributes_for_transfer(
         points, *curve, attribute_outputs);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
index df360818313..c993a3d305d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
@@ -117,10 +117,10 @@ struct TrimLocation {
 };
 
 template<typename T>
-static void shift_slice_to_start(MutableSpan<T> data, const int start_index, const int size)
+static void shift_slice_to_start(MutableSpan<T> data, const int start_index, const int num)
 {
-  BLI_assert(start_index + size - 1 <= data.size());
-  memmove(data.data(), &data[start_index], sizeof(T) * size);
+  BLI_assert(start_index + num - 1 <= data.size());
+  memmove(data.data(), &data[start_index], sizeof(T) * num);
 }
 
 /* Shift slice to start of span and modifies start and end data. */
@@ -129,17 +129,17 @@ static void linear_trim_data(const TrimLocation &start,
                              const TrimLocation &end,
                              MutableSpan<T> data)
 {
-  const int size = end.right_index - start.left_index + 1;
+  const int num = end.right_index - start.left_index + 1;
 
   if (start.left_index > 0) {
-    shift_slice_to_start<T>(data, start.left_index, size);
+    shift_slice_to_start<T>(data, start.left_index, num);
   }
 
   const T start_data = mix2<T>(start.factor, data.first(), data[1]);
-  const T end_data = mix2<T>(end.factor, data[size - 2], data[size - 1]);
+  const T end_data = mix2<T>(end.factor, data[num - 2], data[num - 1]);
 
   data.first() = start_data;
-  data[size - 1] = end_data;
+  data[num - 1] = end_data;
 }
 
 /**
@@ -152,12 +152,12 @@ static void linear_trim_to_output_data(const TrimLocation &start,
                                        Span<T> src,
                                        MutableSpan<T> dst)
 {
-  const int size = end.right_index - start.left_index + 1;
+  const int num = end.right_index - start.left_index + 1;
 
   const T start_data = mix2<T>(start.factor, src[start.left_index], src[start.right_index]);
   const T end_data = mix2<T>(end.factor, src[end.left_index], src[end.right_index]);
 
-  dst.copy_from(src.slice(start.left_index, size));
+  dst.copy_from(src.slice(start.left_index, num));
   dst.first() = start_data;
   dst.last() = end_data;
 }
@@ -175,8 +175,8 @@ static TrimLocation lookup_control_point_position(const Spline::LookupResult &lo
   const int right = left == (spline.size() - 1) ? 0 : left + 1;
 
   const float offset_in_segment = lookup.evaluated_index + lookup.factor - offsets[left];
-  const int segment_eval_size = offsets[left + 1] - offsets[left];
-  const float factor = std::clamp(offset_in_segment / segment_eval_size, 0.0f, 1.0f);
+  const int segment_eval_num = offsets[left + 1] - offsets[left];
+  const float factor = std::clamp(offset_in_segment / segment_eval_num, 0.0f, 1.0f);
 
   return {left, right, factor};
 }
@@ -191,7 +191,7 @@ static void trim_poly_spline(Spline &spline,
   const TrimLocation end = {
       end_lookup.evaluated_index, end_lookup.next_evaluated_index, end_lookup.factor};
 
-  const int size = end.right_index - start.left_index + 1;
+  const int num = end.right_index - start.left_index + 1;
 
   linear_trim_data<float3>(start, end, spline.positions());
   linear_trim_data<float>(start, end, spline.radii());
@@ -209,7 +209,7 @@ static void trim_poly_spline(Spline &spline,
       },
       ATTR_DOMAIN_POINT);
 
-  spline.resize(size);
+  spline.resize(num);
 }
 
 /**
@@ -225,11 +225,11 @@ static PolySpline trim_nurbs_spline(const Spline &spline,
   const TrimLocation end = {
       end_lookup.evaluated_index, end_lookup.next_evaluated_index, end_lookup.factor};
 
-  const int size = end.right_index - start.left_index + 1;
+  const int num = end.right_index - start.left_index + 1;
 
   /* Create poly spline and copy trimmed data to it. */
   PolySpline new_spline;
-  new_spline.resize(size);
+  new_spline.resize(num);
 
   /* Copy generic attribute data. */
   spline.attributes.foreach_attribute(
@@ -283,7 +283,7 @@ static void trim_bezier_spline(Spline &spline,
   const Span<int> control_offsets = bezier_spline.control_point_offsets();
 
   /* The number of control points in the resulting spline. */
-  const int size = end.right_index - start.left_index + 1;
+  const int num = end.right_index - start.left_index + 1;
 
   /* Trim the spline attributes. Done before end.factor recalculation as it needs
    * the original end.factor value. */
@@ -301,10 +301,10 @@ static void trim_bezier_spline(Spline &spline,
       },
       ATTR_DOMAIN_POINT);
 
-  /* Recalculate end.factor if the size is two, because the adjustment in the
+  /* Recalculate end.factor if the `num` is two, because the adjustment in the
    * position of the control point of the spline to the left of the new end point will change the
    * factor between them. */
-  if (size == 2) {
+  if (num == 2) {
     if (start_lookup.factor == 1.0f) {
       end.factor = 0.0f;
     }
@@ -328,38 +328,38 @@ static void trim_bezier_spline(Spline &spline,
   const BezierSpline::InsertResult end_point = bezier_spline.calculate_segment_insertion(
       end.left_index, end.right_index, end.factor);
 
-  /* If size is two, then the start point right handle needs to change to reflect the end point
+  /* If `num` is two, then the start point right handle needs to change to reflect the end point
    * previous handle update. */
-  if (size == 2) {
+  if (num == 2) {
     start_point.right_handle = end_point.handle_prev;
   }
 
   /* Shift control point position data to start at beginning of array. */
   if (start.left_index > 0) {
-    shift_slice_to_start(bezier_spline.positions(), start.left_index, size);
-    shift_slice_to_start(bezier_spline.handle_positions_left(), start.left_index, size);
-    shift_slice_to_start(bezier_spline.handle_positions_right(), start.left_index, size);
+    shift_slice_to_start(bezier_spline.positions(), start.left_index, num);
+    shift_slice_to_start(bezier_spline.handle_positions_left(), start.left_index, num);
+    shift_slice_to_start(bezier_spline.handle_positions_right(), start.left_index, num);
   }
 
   bezier_spline.positions().first() = start_point.position;
-  bezier_spline.positions()[size - 1] = end_point.position;
+  bezier_spline.positions()[num - 1] = end_point.position;
 
   bezier_spline.handle_positions_left().first() = start_point.left_handle;
-  bezier_spline.handle_positions_left()[size - 1] = end_point.left_handle;
+  bezier_spline.handle_positions_left()[num - 1] = end_point.left_handle;
 
   bezier_spline.handle_positions_right().first() = start_point.right_handle;
-  bezier_spline.handle_positions_right()[size - 1] = end_point.right_handle;
+  bezier_spline.handle_positions_right()[num - 1] = end_point.right_handle;
 
   /* If there is at least one control point between the endpoints, update the control
    * point handle to the right of the start point and to the left of the end point. */
-  if (size > 2) {
+  if (num > 2) {
     bezier_spline.handle_positions_left()[start.right_index - start.left_index] =
         start_point.handle_next;
     bezier_spline.handle_positions_right()[end.left_index - start.left_index] =
         end_point.handle_prev;
   }
 
-  bezier_spline.resize(size);
+  bezier_spline.resize(num);
 }
 
 static void trim_spline(SplinePtr &spline,
@@ -506,9 +506,9 @@ static void geometry_set_curve_trim(GeometrySet &geometry_set,
 
   CurveComponent &component = geometry_set.get_component_for_write<CurveComponent>();
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_CURVE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_CURVE);
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_CURVE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.add(start_field);
   evaluator.add(end_field);
   evaluator.evaluate();
@@ -527,7 +527,7 @@ static void geometry_set_curve_trim(GeometrySet &geometry_set,
         continue;
       }
 
-      if (spline->evaluated_edges_size() == 0) {
+      if (spline->evaluated_edges_num() == 0) {
         continue;
       }
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
index 8a0c900fbde..99edc4d298c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
@@ -470,7 +470,7 @@ static void separate_curve_selection(GeometrySet &geometry_set,
   GeometryComponentFieldContext field_context{src_component, selection_domain};
 
   fn::FieldEvaluator selection_evaluator{field_context,
-                                         src_component.attribute_domain_size(selection_domain)};
+                                         src_component.attribute_domain_num(selection_domain)};
   selection_evaluator.add(selection_field);
   selection_evaluator.evaluate();
   const VArray_Span<bool> &selection = selection_evaluator.get_evaluated<bool>(0);
@@ -493,7 +493,7 @@ static void separate_point_cloud_selection(GeometrySet &geometry_set,
   GeometryComponentFieldContext field_context{src_points, ATTR_DOMAIN_POINT};
 
   fn::FieldEvaluator selection_evaluator{field_context,
-                                         src_points.attribute_domain_size(ATTR_DOMAIN_POINT)};
+                                         src_points.attribute_domain_num(ATTR_DOMAIN_POINT)};
   selection_evaluator.add(selection_field);
   selection_evaluator.evaluate();
   const VArray_Span<bool> &selection = selection_evaluator.get_evaluated<bool>(0);
@@ -526,8 +526,8 @@ static void separate_instance_selection(GeometrySet &geometry_set,
   InstancesComponent &instances = geometry_set.get_component_for_write<InstancesComponent>();
   GeometryComponentFieldContext field_context{instances, ATTR_DOMAIN_INSTANCE};
 
-  const int domain_size = instances.attribute_domain_size(ATTR_DOMAIN_INSTANCE);
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  const int domain_num = instances.attribute_domain_num(ATTR_DOMAIN_INSTANCE);
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.add(selection_field);
   evaluator.evaluate();
   const VArray_Span<bool> &selection = evaluator.get_evaluated<bool>(0);
@@ -1238,7 +1238,7 @@ static void separate_mesh_selection(GeometrySet &geometry_set,
   GeometryComponentFieldContext field_context{src_component, selection_domain};
 
   fn::FieldEvaluator selection_evaluator{field_context,
-                                         src_component.attribute_domain_size(selection_domain)};
+                                         src_component.attribute_domain_num(selection_domain)};
   selection_evaluator.add(selection_field);
   selection_evaluator.evaluate();
   const VArray_Span<bool> &selection = selection_evaluator.get_evaluated<bool>(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
index d9f29d1ef1c..c242cfd5cf3 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
@@ -398,11 +398,11 @@ static Array<float> calc_full_density_factors_with_selection(const MeshComponent
 {
   const AttributeDomain attribute_domain = ATTR_DOMAIN_CORNER;
   GeometryComponentFieldContext field_context{component, attribute_domain};
-  const int domain_size = component.attribute_domain_size(attribute_domain);
+  const int domain_num = component.attribute_domain_num(attribute_domain);
 
-  Array<float> densities(domain_size, 0.0f);
+  Array<float> densities(domain_num, 0.0f);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(density_field, densities.as_mutable_span());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
index 1b26cfe31fe..ee3de995cb1 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
@@ -351,19 +351,19 @@ static void duplicate_curves(GeometrySet &geometry_set,
   Array<int> curve_offsets(selection.size() + 1);
   Array<int> point_offsets(selection.size() + 1);
 
-  int dst_curves_size = 0;
-  int dst_points_size = 0;
+  int dst_curves_num = 0;
+  int dst_points_num = 0;
   for (const int i_curve : selection.index_range()) {
     const int count = std::max(counts[selection[i_curve]], 0);
-    curve_offsets[i_curve] = dst_curves_size;
-    point_offsets[i_curve] = dst_points_size;
-    dst_curves_size += count;
-    dst_points_size += count * curves.points_for_curve(selection[i_curve]).size();
+    curve_offsets[i_curve] = dst_curves_num;
+    point_offsets[i_curve] = dst_points_num;
+    dst_curves_num += count;
+    dst_points_num += count * curves.points_for_curve(selection[i_curve]).size();
   }
-  curve_offsets.last() = dst_curves_size;
-  point_offsets.last() = dst_points_size;
+  curve_offsets.last() = dst_curves_num;
+  point_offsets.last() = dst_points_num;
 
-  Curves *new_curves_id = bke::curves_new_nomain(dst_points_size, dst_curves_size);
+  Curves *new_curves_id = bke::curves_new_nomain(dst_points_num, dst_curves_num);
   bke::CurvesGeometry &new_curves = bke::CurvesGeometry::wrap(new_curves_id->geometry);
   MutableSpan<int> all_dst_offsets = new_curves.offsets_for_write();
 
@@ -379,7 +379,7 @@ static void duplicate_curves(GeometrySet &geometry_set,
       }
     }
   });
-  all_dst_offsets.last() = dst_points_size;
+  all_dst_offsets.last() = dst_points_num;
 
   CurveComponent dst_component;
   dst_component.replace(new_curves_id, GeometryOwnershipType::Editable);
@@ -807,7 +807,7 @@ static void duplicate_points_curve(GeometrySet &geometry_set,
   const IndexMask selection = evaluator.get_evaluated_selection_as_mask();
 
   Array<int> offsets = accumulate_counts_to_offsets(selection, counts);
-  const int dst_size = offsets.last();
+  const int dst_num = offsets.last();
 
   Array<int> point_to_curve_map(src_curves.points_num());
   threading::parallel_for(src_curves.curves_range(), 1024, [&](const IndexRange range) {
@@ -817,13 +817,13 @@ static void duplicate_points_curve(GeometrySet &geometry_set,
     }
   });
 
-  Curves *new_curves_id = bke::curves_new_nomain(dst_size, dst_size);
+  Curves *new_curves_id = bke::curves_new_nomain(dst_num, dst_num);
   bke::CurvesGeometry &new_curves = bke::CurvesGeometry::wrap(new_curves_id->geometry);
   MutableSpan<int> new_curve_offsets = new_curves.offsets_for_write();
   for (const int i : new_curves.curves_range()) {
     new_curve_offsets[i] = i;
   }
-  new_curve_offsets.last() = dst_size;
+  new_curve_offsets.last() = dst_num;
 
   CurveComponent dst_component;
   dst_component.replace(new_curves_id, GeometryOwnershipType::Editable);
@@ -940,10 +940,10 @@ static void duplicate_points_pointcloud(GeometrySet &geometry_set,
 {
   const PointCloudComponent &src_points =
       *geometry_set.get_component_for_read<PointCloudComponent>();
-  const int point_size = src_points.attribute_domain_size(ATTR_DOMAIN_POINT);
+  const int point_num = src_points.attribute_domain_num(ATTR_DOMAIN_POINT);
 
   GeometryComponentFieldContext field_context{src_points, ATTR_DOMAIN_POINT};
-  FieldEvaluator evaluator{field_context, point_size};
+  FieldEvaluator evaluator{field_context, point_num};
   evaluator.add(count_field);
   evaluator.set_selection(selection_field);
   evaluator.evaluate();
@@ -1026,7 +1026,7 @@ static void duplicate_instances(GeometrySet &geometry_set,
       *geometry_set.get_component_for_read<InstancesComponent>();
 
   GeometryComponentFieldContext field_context{src_instances, ATTR_DOMAIN_INSTANCE};
-  FieldEvaluator evaluator{field_context, src_instances.instances_amount()};
+  FieldEvaluator evaluator{field_context, src_instances.instances_num()};
   evaluator.add(count_field);
   evaluator.set_selection(selection_field);
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
index 84acab47661..94fbec66bfe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
@@ -57,8 +57,8 @@ static void node_geo_exec(GeoNodeExecParams params)
 
     const MeshComponent &mesh_component = *geometry_set.get_component_for_read<MeshComponent>();
     GeometryComponentFieldContext field_context{mesh_component, ATTR_DOMAIN_EDGE};
-    const int domain_size = mesh_component.attribute_domain_size(ATTR_DOMAIN_EDGE);
-    fn::FieldEvaluator selection_evaluator{field_context, domain_size};
+    const int domain_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_EDGE);
+    fn::FieldEvaluator selection_evaluator{field_context, domain_num};
     selection_evaluator.add(selection_field);
     selection_evaluator.evaluate();
     const IndexMask selection = selection_evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_field_at_index.cc b/source/blender/nodes/geometry/nodes/node_geo_field_at_index.cc
index 77be98f169e..bf956f3b83d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_field_at_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_field_at_index.cc
@@ -91,7 +91,7 @@ class FieldAtIndex final : public GeometryFieldInput {
   {
     const GeometryComponentFieldContext value_field_context{component, value_field_domain_};
     FieldEvaluator value_evaluator{value_field_context,
-                                   component.attribute_domain_size(value_field_domain_)};
+                                   component.attribute_domain_num(value_field_domain_)};
     value_evaluator.add(value_field_);
     value_evaluator.evaluate();
     const GVArray &values = value_evaluator.get_evaluated(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc
index 34c3169065c..0484017cf3b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc
@@ -22,11 +22,11 @@ static void node_declare(NodeDeclarationBuilder &b)
 static void mesh_flip_faces(MeshComponent &component, const Field<bool> &selection_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_FACE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_FACE);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_FACE);
+  if (domain_num == 0) {
     return;
   }
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.add(selection_field);
   evaluator.evaluate();
   const IndexMask selection = evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
index d39291a2a7e..8e3a9b6769d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
@@ -101,8 +101,7 @@ class IslandCountFieldInput final : public GeometryFieldInput {
       island_list.add(root);
     }
 
-    return VArray<int>::ForSingle(island_list.size(),
-                                  mesh_component.attribute_domain_size(domain));
+    return VArray<int>::ForSingle(island_list.size(), mesh_component.attribute_domain_num(domain));
   }
 
   uint64_t hash() const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
index 61f719ade4e..12582f9e9c6 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
@@ -50,7 +50,7 @@ static void add_instances_from_component(
     const Map<AttributeIDRef, AttributeKind> &attributes_to_propagate)
 {
   const AttributeDomain domain = ATTR_DOMAIN_POINT;
-  const int domain_size = src_component.attribute_domain_size(domain);
+  const int domain_num = src_component.attribute_domain_num(domain);
 
   VArray<bool> pick_instance;
   VArray<int> indices;
@@ -59,7 +59,7 @@ static void add_instances_from_component(
 
   GeometryComponentFieldContext field_context{src_component, domain};
   const Field<bool> selection_field = params.get_input<Field<bool>>("Selection");
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   /* The evaluator could use the component's stable IDs as a destination directly, but only the
    * selected indices should be copied. */
@@ -73,7 +73,7 @@ static void add_instances_from_component(
 
   /* The initial size of the component might be non-zero when this function is called for multiple
    * component types. */
-  const int start_len = dst_component.instances_amount();
+  const int start_len = dst_component.instances_num();
   const int select_len = selection.index_range().size();
   dst_component.resize(start_len + select_len);
 
@@ -119,12 +119,12 @@ static void add_instances_from_component(
       const bool use_individual_instance = pick_instance[i];
       if (use_individual_instance) {
         if (src_instances != nullptr) {
-          const int src_instances_amount = src_instances->instances_amount();
+          const int src_instances_num = src_instances->instances_num();
           const int original_index = indices[i];
           /* Use #mod_i instead of `%` to get the desirable wrap around behavior where -1
            * refers to the last element. */
-          const int index = mod_i(original_index, std::max(src_instances_amount, 1));
-          if (index < src_instances_amount) {
+          const int index = mod_i(original_index, std::max(src_instances_num, 1));
+          if (index < src_instances_num) {
             /* Get the reference to the source instance. */
             const int src_handle = src_instances->instance_reference_handles()[index];
             dst_handle = handle_mapping[src_handle];
diff --git a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
index e35f152ce49..2126a5cc329 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
@@ -40,9 +40,9 @@ static void convert_instances_to_points(GeometrySet &geometry_set,
   const InstancesComponent &instances = *geometry_set.get_component_for_read<InstancesComponent>();
 
   GeometryComponentFieldContext field_context{instances, ATTR_DOMAIN_INSTANCE};
-  const int domain_size = instances.attribute_domain_size(ATTR_DOMAIN_INSTANCE);
+  const int domain_num = instances.attribute_domain_num(ATTR_DOMAIN_INSTANCE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(std::move(selection_field));
   evaluator.add(std::move(position_field));
   evaluator.add(std::move(radius_field));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
index 0e2803cd035..2067086c298 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
@@ -56,8 +56,8 @@ static void fill_new_attribute(Span<const GeometryComponent *> src_components,
 
   int offset = 0;
   for (const GeometryComponent *component : src_components) {
-    const int domain_size = component->attribute_domain_size(domain);
-    if (domain_size == 0) {
+    const int domain_num = component->attribute_domain_num(domain);
+    if (domain_num == 0) {
       continue;
     }
     GVArray read_attribute = component->attribute_get_for_read(
@@ -66,9 +66,9 @@ static void fill_new_attribute(Span<const GeometryComponent *> src_components,
     GVArray_GSpan src_span{read_attribute};
     const void *src_buffer = src_span.data();
     void *dst_buffer = dst_span[offset];
-    cpp_type->copy_assign_n(src_buffer, dst_buffer, domain_size);
+    cpp_type->copy_assign_n(src_buffer, dst_buffer, domain_num);
 
-    offset += domain_size;
+    offset += domain_num;
   }
 }
 
@@ -101,7 +101,7 @@ static void join_components(Span<const InstancesComponent *> src_components, Geo
 
   int tot_instances = 0;
   for (const InstancesComponent *src_component : src_components) {
-    tot_instances += src_component->instances_amount();
+    tot_instances += src_component->instances_num();
   }
   dst_component.reserve(tot_instances);
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc b/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc
index 1ec97858d4d..1def4089115 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc
@@ -39,9 +39,9 @@ static PointCloud *pointcloud_merge_by_distance(const PointCloudComponent &src_p
                                                 const float merge_distance,
                                                 const Field<bool> &selection_field)
 {
-  const int src_size = src_points.attribute_domain_size(ATTR_DOMAIN_POINT);
+  const int src_num = src_points.attribute_domain_num(ATTR_DOMAIN_POINT);
   GeometryComponentFieldContext context{src_points, ATTR_DOMAIN_POINT};
-  FieldEvaluator evaluator{context, src_size};
+  FieldEvaluator evaluator{context, src_num};
   evaluator.add(selection_field);
   evaluator.evaluate();
 
@@ -57,10 +57,10 @@ static std::optional<Mesh *> mesh_merge_by_distance_connected(const MeshComponen
                                                               const float merge_distance,
                                                               const Field<bool> &selection_field)
 {
-  const int src_size = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  Array<bool> selection(src_size);
+  const int src_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  Array<bool> selection(src_num);
   GeometryComponentFieldContext context{mesh_component, ATTR_DOMAIN_POINT};
-  FieldEvaluator evaluator{context, src_size};
+  FieldEvaluator evaluator{context, src_num};
   evaluator.add_with_destination(selection_field, selection.as_mutable_span());
   evaluator.evaluate();
 
@@ -72,9 +72,9 @@ static std::optional<Mesh *> mesh_merge_by_distance_all(const MeshComponent &mes
                                                         const float merge_distance,
                                                         const Field<bool> &selection_field)
 {
-  const int src_size = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
+  const int src_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_POINT);
   GeometryComponentFieldContext context{mesh_component, ATTR_DOMAIN_POINT};
-  FieldEvaluator evaluator{context, src_size};
+  FieldEvaluator evaluator{context, src_num};
   evaluator.add(selection_field);
   evaluator.evaluate();
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
index f6ee3d00dee..ec6acf55dd8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
@@ -25,7 +25,7 @@ static void node_geo_exec(GeoNodeExecParams params)
 
     const MeshComponent &component = *geometry_set.get_component_for_read<MeshComponent>();
     GeometryComponentFieldContext context{component, ATTR_DOMAIN_EDGE};
-    fn::FieldEvaluator evaluator{context, component.attribute_domain_size(ATTR_DOMAIN_EDGE)};
+    fn::FieldEvaluator evaluator{context, component.attribute_domain_num(ATTR_DOMAIN_EDGE)};
     evaluator.add(params.get_input<Field<bool>>("Selection"));
     evaluator.evaluate();
     const IndexMask selection = evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
index 2ed6d555684..6b23b685549 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
@@ -66,12 +66,12 @@ static void geometry_set_mesh_to_points(GeometrySet &geometry_set,
     return;
   }
   GeometryComponentFieldContext field_context{*mesh_component, domain};
-  const int domain_size = mesh_component->attribute_domain_size(domain);
-  if (domain_size == 0) {
+  const int domain_num = mesh_component->attribute_domain_num(domain);
+  if (domain_num == 0) {
     geometry_set.keep_only({GEO_COMPONENT_TYPE_INSTANCES});
     return;
   }
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   /* Evaluating directly into the point cloud doesn't work because we are not using the full
    * "min_array_size" array but compressing the selected elements into the final array with no
diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
index 0f6586617bc..577b001fd06 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
@@ -38,13 +38,13 @@ static void geometry_set_points_to_vertices(GeometrySet &geometry_set,
   }
 
   GeometryComponentFieldContext field_context{*point_component, ATTR_DOMAIN_POINT};
-  const int domain_size = point_component->attribute_domain_size(ATTR_DOMAIN_POINT);
-  if (domain_size == 0) {
+  const int domain_num = point_component->attribute_domain_num(ATTR_DOMAIN_POINT);
+  if (domain_num == 0) {
     geometry_set.keep_only({GEO_COMPONENT_TYPE_INSTANCES});
     return;
   }
 
-  fn::FieldEvaluator selection_evaluator{field_context, domain_size};
+  fn::FieldEvaluator selection_evaluator{field_context, domain_num};
   selection_evaluator.add(selection_field);
   selection_evaluator.evaluate();
   const IndexMask selection = selection_evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
index c99b51ffd4c..42cee4c0efe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
@@ -168,14 +168,14 @@ static void gather_point_data_from_component(GeoNodeExecParams &params,
 
   Field<float> radius_field = params.get_input<Field<float>>("Radius");
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
 
-  r_positions.resize(r_positions.size() + domain_size);
-  positions.materialize(r_positions.as_mutable_span().take_back(domain_size));
+  r_positions.resize(r_positions.size() + domain_num);
+  positions.materialize(r_positions.as_mutable_span().take_back(domain_num));
 
-  r_radii.resize(r_radii.size() + domain_size);
-  fn::FieldEvaluator evaluator{field_context, domain_size};
-  evaluator.add_with_destination(radius_field, r_radii.as_mutable_span().take_back(domain_size));
+  r_radii.resize(r_radii.size() + domain_num);
+  fn::FieldEvaluator evaluator{field_context, domain_num};
+  evaluator.add_with_destination(radius_field, r_radii.as_mutable_span().take_back(domain_num));
   evaluator.evaluate();
 }
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
index 368954447c9..0c30d50076f 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
@@ -312,8 +312,8 @@ class RaycastFunction : public fn::MultiFunction {
     }
     const MeshComponent &mesh_component = *target_.get_component_for_read<MeshComponent>();
     target_context_.emplace(GeometryComponentFieldContext{mesh_component, domain_});
-    const int domain_size = mesh_component.attribute_domain_size(domain_);
-    target_evaluator_ = std::make_unique<FieldEvaluator>(*target_context_, domain_size);
+    const int domain_num = mesh_component.attribute_domain_num(domain_);
+    target_evaluator_ = std::make_unique<FieldEvaluator>(*target_context_, domain_num);
     target_evaluator_->add(std::move(src_field));
     target_evaluator_->evaluate();
     target_data_ = &target_evaluator_->get_evaluated(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
index 6eb95859e50..59e203afd08 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
@@ -19,9 +19,9 @@ static void node_declare(NodeDeclarationBuilder &b)
 static void rotate_instances(GeoNodeExecParams &params, InstancesComponent &instances_component)
 {
   GeometryComponentFieldContext field_context{instances_component, ATTR_DOMAIN_INSTANCE};
-  const int domain_size = instances_component.instances_amount();
+  const int domain_num = instances_component.instances_num();
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(params.extract_input<Field<bool>>("Selection"));
   evaluator.add(params.extract_input<Field<float3>>("Rotation"));
   evaluator.add(params.extract_input<Field<float3>>("Pivot Point"));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
index 4ca21874f8f..d4716a6b6f0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
@@ -23,7 +23,7 @@ static void scale_instances(GeoNodeExecParams &params, InstancesComponent &insta
 {
   GeometryComponentFieldContext field_context{instances_component, ATTR_DOMAIN_INSTANCE};
 
-  fn::FieldEvaluator evaluator{field_context, instances_component.instances_amount()};
+  fn::FieldEvaluator evaluator{field_context, instances_component.instances_num()};
   evaluator.set_selection(params.extract_input<Field<bool>>("Selection"));
   evaluator.add(params.extract_input<Field<float3>>("Scale"));
   evaluator.add(params.extract_input<Field<float3>>("Center"));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
index 73e49c7d037..d2082924fa7 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
@@ -75,12 +75,12 @@ static void set_position_in_component(CurveComponent &component,
                                       const Field<float3> &offset_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  if (domain_num == 0) {
     return;
   }
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add(position_field);
   evaluator.add(offset_field);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
index a23a6c09551..4c84093bfcb 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
@@ -21,15 +21,15 @@ static void set_radius_in_component(GeometryComponent &component,
                                     const Field<float> &radius_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<float> radii = component.attribute_try_get_for_output_only<float>(
       "radius", ATTR_DOMAIN_POINT);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(radius_field, radii.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
index 1155c97dc38..8b1e5935a61 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
@@ -17,15 +17,15 @@ static void set_tilt_in_component(GeometryComponent &component,
                                   const Field<float> &tilt_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<float> tilts = component.attribute_try_get_for_output_only<float>(
       "tilt", ATTR_DOMAIN_POINT);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(tilt_field, tilts.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
index 0892e068ce2..ec95f9a89f5 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
@@ -20,12 +20,12 @@ static void set_id_in_component(GeometryComponent &component,
                                      ATTR_DOMAIN_INSTANCE :
                                      ATTR_DOMAIN_POINT;
   GeometryComponentFieldContext field_context{component, domain};
-  const int domain_size = component.attribute_domain_size(domain);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(domain);
+  if (domain_num == 0) {
     return;
   }
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
 
   /* Since adding the ID attribute can change the result of the field evaluation (the random value
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
index a0b38209f97..58613dae832 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
@@ -17,15 +17,15 @@ static void set_material_index_in_component(GeometryComponent &component,
                                             const Field<int> &index_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_FACE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_FACE);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_FACE);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<int> indices = component.attribute_try_get_for_output_only<int>(
       "material_index", ATTR_DOMAIN_FACE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(index_field, indices.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
index 93024fd81d6..571bead9743 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
@@ -21,15 +21,15 @@ static void set_radius_in_component(GeometryComponent &component,
                                     const Field<float> &radius_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_POINT);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<float> radii = component.attribute_try_get_for_output_only<float>(
       "radius", ATTR_DOMAIN_POINT);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(radius_field, radii.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
index d2ff9753897..caf33108716 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
@@ -143,12 +143,12 @@ static void set_position_in_component(GeometryComponent &component,
                                ATTR_DOMAIN_INSTANCE :
                                ATTR_DOMAIN_POINT;
   GeometryComponentFieldContext field_context{component, domain};
-  const int domain_size = component.attribute_domain_size(domain);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(domain);
+  if (domain_num == 0) {
     return;
   }
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add(position_field);
   evaluator.add(offset_field);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
index 3420e17cc10..b98fbd0a0fe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
@@ -17,15 +17,15 @@ static void set_smooth_in_component(GeometryComponent &component,
                                     const Field<bool> &shade_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_FACE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_FACE);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_FACE);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<bool> shades = component.attribute_try_get_for_output_only<bool>(
       "shade_smooth", ATTR_DOMAIN_FACE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(shade_field, shades.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
index dc7f3b1343a..976857883f0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
@@ -17,15 +17,15 @@ static void set_cyclic_in_component(GeometryComponent &component,
                                     const Field<bool> &cyclic_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_CURVE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_CURVE);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_CURVE);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<bool> cyclics = component.attribute_try_get_for_output_only<bool>(
       "cyclic", ATTR_DOMAIN_CURVE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(cyclic_field, cyclics.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
index f3031ff3678..8b665376c01 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
@@ -17,15 +17,15 @@ static void set_resolution_in_component(GeometryComponent &component,
                                         const Field<int> &resolution_field)
 {
   GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_CURVE};
-  const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_CURVE);
-  if (domain_size == 0) {
+  const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_CURVE);
+  if (domain_num == 0) {
     return;
   }
 
   OutputAttribute_Typed<int> resolutions = component.attribute_try_get_for_output_only<int>(
       "resolution", ATTR_DOMAIN_CURVE);
 
-  fn::FieldEvaluator evaluator{field_context, domain_size};
+  fn::FieldEvaluator evaluator{field_context, domain_num};
   evaluator.set_selection(selection_field);
   evaluator.add_with_destination(resolution_field, resolutions.varray());
   evaluator.evaluate();
diff --git a/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc
index de206be5367..3b348dd0136 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc
@@ -88,8 +88,8 @@ static void try_capture_field_on_geometry(GeometryComponent &component,
                                           const GField &field)
 {
   GeometryComponentFieldContext field_context{component, domain};
-  const int domain_size = component.attribute_domain_size(domain);
-  const IndexMask mask{IndexMask(domain_size)};
+  const int domain_num = component.attribute_domain_num(domain);
+  const IndexMask mask{IndexMask(domain_num)};
 
   const CPPType &type = field.cpp_type();
   const CustomDataType data_type = bke::cpp_type_to_custom_data_type(type);
@@ -97,10 +97,10 @@ static void try_capture_field_on_geometry(GeometryComponent &component,
   /* Could avoid allocating a new buffer if:
    * - We are writing to an attribute that exists already.
    * - The field does not depend on that attribute (we can't easily check for that yet). */
-  void *buffer = MEM_mallocN(type.size() * domain_size, __func__);
+  void *buffer = MEM_mallocN(type.size() * domain_num, __func__);
 
   fn::FieldEvaluator evaluator{field_context, &mask};
-  evaluator.add_with_destination(field, GMutableSpan{type, buffer, domain_size});
+  evaluator.add_with_destination(field, GMutableSpan{type, buffer, domain_num});
   evaluator.evaluate();
 
   component.attribute_try_delete(name);
@@ -114,7 +114,7 @@ static void try_capture_field_on_geometry(GeometryComponent &component,
     else {
       /* Cannot change type of built-in attribute. */
     }
-    type.destruct_n(buffer, domain_size);
+    type.destruct_n(buffer, domain_num);
     MEM_freeN(buffer);
   }
   else {
diff --git a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
index f2a859065c6..9eda5bb34ff 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
@@ -118,8 +118,8 @@ static void node_geo_exec(GeoNodeExecParams params)
     }
 
     const MeshComponent &mesh_component = *geometry_set.get_component_for_read<MeshComponent>();
-    const int verts_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
-    const int edges_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_EDGE);
+    const int verts_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_POINT);
+    const int edges_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_EDGE);
     if (verts_num == 0 || edges_num == 0) {
       return;
     }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
index 12e306ba480..dca214660c8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
@@ -365,7 +365,7 @@ static bool component_is_available(const GeometrySet &geometry,
   if (component.is_empty()) {
     return false;
   }
-  return component.attribute_domain_size(domain) != 0;
+  return component.attribute_domain_num(domain) != 0;
 }
 
 /**
@@ -433,8 +433,8 @@ class NearestInterpolatedTransferFunction : public fn::MultiFunction {
   {
     const MeshComponent &mesh_component = *source_.get_component_for_read<MeshComponent>();
     source_context_.emplace(GeometryComponentFieldContext{mesh_component, domain_});
-    const int domain_size = mesh_component.attribute_domain_size(domain_);
-    source_evaluator_ = std::make_unique<FieldEvaluator>(*source_context_, domain_size);
+    const int domain_num = mesh_component.attribute_domain_num(domain_);
+    source_evaluator_ = std::make_unique<FieldEvaluator>(*source_context_, domain_num);
     source_evaluator_->add(src_field_);
     source_evaluator_->evaluate();
     source_data_ = &source_evaluator_->get_evaluated(0);
@@ -578,9 +578,9 @@ class NearestTransferFunction : public fn::MultiFunction {
   {
     if (use_mesh_) {
       const MeshComponent &mesh = *source_.get_component_for_read<MeshComponent>();
-      const int domain_size = mesh.attribute_domain_size(domain_);
+      const int domain_num = mesh.attribute_domain_num(domain_);
       mesh_context_.emplace(GeometryComponentFieldContext(mesh, domain_));
-      mesh_evaluator_ = std::make_unique<FieldEvaluator>(*mesh_context_, domain_size);
+      mesh_evaluator_ = std::make_unique<FieldEvaluator>(*mesh_context_, domain_num);
       mesh_evaluator_->add(src_field_);
       mesh_evaluator_->evaluate();
       mesh_data_ = &mesh_evaluator_->get_evaluated(0);
@@ -588,9 +588,9 @@ class NearestTransferFunction : public fn::MultiFunction {
 
     if (use_points_) {
       const PointCloudComponent &points = *source_.get_component_for_read<PointCloudComponent>();
-      const int domain_size = points.attribute_domain_size(domain_);
+      const int domain_num = points.attribute_domain_num(domain_);
       point_context_.emplace(GeometryComponentFieldContext(points, domain_));
-      point_evaluator_ = std::make_unique<FieldEvaluator>(*point_context_, domain_size);
+      point_evaluator_ = std::make_unique<FieldEvaluator>(*point_context_, domain_num);
       point_evaluator_->add(src_field_);
       point_evaluator_->evaluate();
       point_data_ = &point_evaluator_->get_evaluated(0);
@@ -658,9 +658,9 @@ class IndexTransferFunction : public fn::MultiFunction {
     if (component == nullptr) {
       return;
     }
-    const int domain_size = component->attribute_domain_size(domain_);
+    const int domain_num = component->attribute_domain_num(domain_);
     geometry_context_.emplace(GeometryComponentFieldContext(*component, domain_));
-    evaluator_ = std::make_unique<FieldEvaluator>(*geometry_context_, domain_size);
+    evaluator_ = std::make_unique<FieldEvaluator>(*geometry_context_, domain_num);
     evaluator_->add(src_field_);
     evaluator_->evaluate();
     src_data_ = &evaluator_->get_evaluated(0);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
index a5ca1cba28f..258c1ac3fba 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
@@ -19,7 +19,7 @@ static void translate_instances(GeoNodeExecParams &params, InstancesComponent &i
 {
   GeometryComponentFieldContext field_context{instances_component, ATTR_DOMAIN_INSTANCE};
 
-  fn::FieldEvaluator evaluator{field_context, instances_component.instances_amount()};
+  fn::FieldEvaluator evaluator{field_context, instances_component.instances_num()};
   evaluator.set_selection(params.extract_input<Field<bool>>("Selection"));
   evaluator.add(params.extract_input<Field<float3>>("Translation"));
   evaluator.add(params.extract_input<Field<bool>>("Local Space"));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
index 992470e8279..e47dc22da04 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
@@ -83,9 +83,9 @@ static void node_geo_exec(GeoNodeExecParams params)
     GeometryComponent &component = geometry_set.get_component_for_write<MeshComponent>();
     const Mesh &mesh_in = *geometry_set.get_mesh_for_read();
 
-    const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_FACE);
+    const int domain_num = component.attribute_domain_num(ATTR_DOMAIN_FACE);
     GeometryComponentFieldContext context{component, ATTR_DOMAIN_FACE};
-    FieldEvaluator evaluator{context, domain_size};
+    FieldEvaluator evaluator{context, domain_num};
     evaluator.add(selection_field);
     evaluator.evaluate();
     const IndexMask selection = evaluator.get_evaluated_as_mask(0);
diff --git a/source/blender/nodes/intern/geometry_nodes_eval_log.cc b/source/blender/nodes/intern/geometry_nodes_eval_log.cc
index 378bac894e8..9a316190720 100644
--- a/source/blender/nodes/intern/geometry_nodes_eval_log.cc
+++ b/source/blender/nodes/intern/geometry_nodes_eval_log.cc
@@ -241,27 +241,27 @@ GeometryValueLog::GeometryValueLog(const GeometrySet &geometry_set, bool log_ful
       case GEO_COMPONENT_TYPE_MESH: {
         const MeshComponent &mesh_component = *(const MeshComponent *)component;
         MeshInfo &info = this->mesh_info.emplace();
-        info.tot_verts = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
-        info.tot_edges = mesh_component.attribute_domain_size(ATTR_DOMAIN_EDGE);
-        info.tot_faces = mesh_component.attribute_domain_size(ATTR_DOMAIN_FACE);
+        info.verts_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_POINT);
+        info.edges_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_EDGE);
+        info.faces_num = mesh_component.attribute_domain_num(ATTR_DOMAIN_FACE);
         break;
       }
       case GEO_COMPONENT_TYPE_CURVE: {
         const CurveComponent &curve_component = *(const CurveComponent *)component;
         CurveInfo &info = this->curve_info.emplace();
-        info.tot_splines = curve_component.attribute_domain_size(ATTR_DOMAIN_CURVE);
+        info.splines_num = curve_component.attribute_domain_num(ATTR_DOMAIN_CURVE);
         break;
       }
       case GEO_COMPONENT_TYPE_POINT_CLOUD: {
         const PointCloudComponent &pointcloud_component = *(const PointCloudComponent *)component;
         PointCloudInfo &info = this->pointcloud_info.emplace();
-        info.tot_points = pointcloud_component.attribute_domain_size(ATTR_DOMAIN_POINT);
+        info.points_num = pointcloud_component.attribute_domain_num(ATTR_DOMAIN_POINT);
         break;
       }
       case GEO_COMPONENT_TYPE_INSTANCES: {
         const InstancesComponent &instances_component = *(const InstancesComponent *)component;
         InstancesInfo &info = this->instances_info.emplace();
-        info.tot_instances = instances_component.instances_amount();
+        info.instances_num = instances_component.instances_num();
         break;
       }
       case GEO_COMPONENT_TYPE_VOLUME: {
diff --git a/source/blender/nodes/intern/node_geometry_exec.cc b/source/blender/nodes/intern/node_geometry_exec.cc
index cea3084a418..39d8c453e43 100644
--- a/source/blender/nodes/intern/node_geometry_exec.cc
+++ b/source/blender/nodes/intern/node_geometry_exec.cc
@@ -119,14 +119,14 @@ GVArray GeoNodeExecParams::get_input_attribute(const StringRef name,
   const bNodeSocket *found_socket = this->find_available_socket(name);
   BLI_assert(found_socket != nullptr); /* There should always be available socket for the name. */
   const CPPType *cpp_type = bke::custom_data_type_to_cpp_type(type);
-  const int64_t domain_size = component.attribute_domain_size(domain);
+  const int64_t domain_num = component.attribute_domain_num(domain);
 
   if (default_value == nullptr) {
     default_value = cpp_type->default_value();
   }
 
   if (found_socket == nullptr) {
-    return GVArray::ForSingle(*cpp_type, domain_size, default_value);
+    return GVArray::ForSingle(*cpp_type, domain_num, default_value);
   }
 
   if (found_socket->type == SOCK_STRING) {
@@ -140,40 +140,40 @@ GVArray GeoNodeExecParams::get_input_attribute(const StringRef name,
     /* If the attribute doesn't exist, use the default value and output an error message
      * (except when the field is empty, to avoid spamming error messages, and not when
      * the domain is empty and we don't expect an attribute anyway). */
-    if (!name.empty() && component.attribute_domain_size(domain) != 0) {
+    if (!name.empty() && component.attribute_domain_num(domain) != 0) {
       this->error_message_add(NodeWarningType::Error,
                               TIP_("No attribute with name \"") + name + "\"");
     }
-    return GVArray::ForSingle(*cpp_type, domain_size, default_value);
+    return GVArray::ForSingle(*cpp_type, domain_num, default_value);
   }
   const bke::DataTypeConversions &conversions = bke::get_implicit_type_conversions();
   if (found_socket->type == SOCK_FLOAT) {
     const float value = this->get_input<float>(found_socket->identifier);
     BUFFER_FOR_CPP_TYPE_VALUE(*cpp_type, buffer);
     conversions.convert_to_uninitialized(CPPType::get<float>(), *cpp_type, &value, buffer);
-    return GVArray::ForSingle(*cpp_type, domain_size, buffer);
+    return GVArray::ForSingle(*cpp_type, domain_num, buffer);
   }
   if (found_socket->type == SOCK_INT) {
     const int value = this->get_input<int>(found_socket->identifier);
     BUFFER_FOR_CPP_TYPE_VALUE(*cpp_type, buffer);
     conversions.convert_to_uninitialized(CPPType::get<int>(), *cpp_type, &value, buffer);
-    return GVArray::ForSingle(*cpp_type, domain_size, buffer);
+    return GVArray::ForSingle(*cpp_type, domain_num, buffer);
   }
   if (found_socket->type == SOCK_VECTOR) {
     const float3 value = this->get_input<float3>(found_socket->identifier);
     BUFFER_FOR_CPP_TYPE_VALUE(*cpp_type, buffer);
     conversions.convert_to_uninitialized(CPPType::get<float3>(), *cpp_type, &value, buffer);
-    return GVArray::ForSingle(*cpp_type, domain_size, buffer);
+    return GVArray::ForSingle(*cpp_type, domain_num, buffer);
   }
   if (found_socket->type == SOCK_RGBA) {
     const ColorGeometry4f value = this->get_input<ColorGeometry4f>(found_socket->identifier);
     BUFFER_FOR_CPP_TYPE_VALUE(*cpp_type, buffer);
     conversions.convert_to_uninitialized(
         CPPType::get<ColorGeometry4f>(), *cpp_type, &value, buffer);
-    return GVArray::ForSingle(*cpp_type, domain_size, buffer);
+    return GVArray::ForSingle(*cpp_type, domain_num, buffer);
   }
   BLI_assert(false);
-  return GVArray::ForSingle(*cpp_type, domain_size, default_value);
+  return GVArray::ForSingle(*cpp_type, domain_num, default_value);
 }
 
 CustomDataType GeoNodeExecParams::get_input_attribute_data_type(