Property and constant sharing

Author: AJenbo

docs/CHANGELOG.md

@@ -36,6 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - **Lower memory use when resolving class hierarchies.** Resolving a class no longer copies every inherited or synthesized member into it. Members that a merge does not actually rewrite are shared with their source across the whole workspace, and the copies a merge does produce (template substitution, trait and interface merging, Eloquent Builder and scope forwarding) are deduplicated so that value-identical results share a single allocation instead of one per class. Method parameter lists are shared the same way. On large Laravel projects, where nearly every Eloquent model resolves through a generic base and forwards the same query-builder methods, this roughly halves the memory held by the resolved-class cache during whole-project analysis and speeds up the merge itself.
+- **Property and constant sharing extends the same memory win.** Inherited and synthesized properties and constants are now shared and interned the same way methods already were, instead of being cloned onto every class that inherits them. This further reduces the resolved-class cache's memory footprint on large projects, on top of the method sharing above.
 - **Classes are pre-resolved for the whole workspace after startup.** Once the background index completes, every known class is resolved in dependency order even when workspace diagnostics are disabled, so the first completion, hover, or go-to-definition against any class reads a warm cache instead of resolving on demand. Edits still re-resolve only the affected classes.
 - **Continuous progress reporting.** The indexing progress bar now advances file by file with live counts (e.g. "Scanning vendor packages (3201/8544 files)") instead of jumping between a few fixed milestones. This covers single-project, monorepo, and non-Composer workspaces. Go to Implementation, Find References, and Type Hierarchy show the same live progress while they scan, including when one of them triggers the first full workspace index.
 - **Property hover now shows effective types as a `var` detail line.** Property hovers now mirror method hovers by displaying the resolved/effective property type above the PHP snippet as `**var**`, while the snippet itself shows only the native PHP property declaration. This keeps docblock-inferred, virtual, and schema-derived property types out of the generated signature block. Contributed by @calebdw.

docs/todo/performance.md

@@ -913,18 +913,20 @@ holds ~247 KB per resolved class.
 
 Two compounding causes:
 
-1. **Inheritance flattening stores a full member copy per class.** Each
+1. **Inheritance flattening stores a member slot per class.** Each
    fully-resolved class stores the complete flattened member set (own +
-   trait + parent + interface + mixin). On the measured project that is
-   648 K method slots across 3 K classes (~214 methods/class), even
-   though only ~20 K unique `MethodInfo` values exist in `method_store`.
-   `resolve_class_with_inheritance` (`inheritance.rs`) shares the
-   `Arc<MethodInfo>` for any inherited method that does not mention a
-   substituted template parameter, so most slots point back at the base
-   class, but every method that does reference a template param (and
-   every class that overrides or enriches one) still holds a distinct
-   allocation. The flattening itself is what the separated-metadata fix
-   below would eliminate.
+   trait + parent + interface + mixin), so a project with ~3 K classes
+   at ~214 members each holds ~648 K method slots. The distinct
+   *allocations* behind those slots are now heavily shared for methods,
+   properties, and constants alike: a slot the merge does not rewrite
+   points back at its source `Arc<MethodInfo>`/`Arc<PropertyInfo>`/
+   `Arc<ConstantInfo>`, and the copies a merge does produce (template
+   substitution, trait / interface / enrichment merges, Eloquent Builder
+   and scope forwarding) are interned so value-identical results
+   collapse to one allocation with a shared parameter list. What remains
+   per class is the flattened `Vec<Arc<_>>` itself — one pointer slot
+   per visible member — which the separated-metadata fix below would
+   eliminate.
 
 2. **The cache is retained for the whole session, unbounded.** Eager
    population plus lazy resolution during the pass fill the cache with
@@ -943,14 +945,19 @@ Fixes, cheapest first (each stands alone):
    cycles are broken by the cache's in-flight set, which `clear()`
    deliberately leaves untouched, so clearing mid-resolution cannot
    resurrect unbounded recursion. **Low-Medium.**
-2. **Separated metadata.** The structural fix: store method
-   identifier `Atom`s per class and keep a single global `MethodInfo`
-   store, resolving members on demand instead of flattening a cloned copy
-   into every class (Mago's model). Eliminates the flattening entirely.
-   This was the endgame of the (now-completed) eager-resolution track;
-   profiling closed it as not worth the rewrite for analysis *speed*,
-   but it remains a valid direction for *memory* if the cache bound above
-   proves insufficient. **High.**
+2. **Separated metadata.** The structural fix for the remaining
+   per-class pointer vectors: store member identifier `Atom`s per class
+   and keep a single global member store, resolving members on demand
+   instead of flattening a per-class `Vec` of pointers (Mago's model).
+   With member *allocations* already shared and interned across methods,
+   properties, and constants, the win left here is the pointer slots
+   themselves. This needs substitution moved to query time to fit
+   PHPantom's transform-on-inherit model (an inherited member is not
+   byte-identical to the declaring class's once template substitution or
+   bare-`self` rewriting applies, so a pure `(fqn, name)` redirect would
+   lose the transform). Profiling closed this as not worth the rewrite
+   for analysis *speed*; it remains a valid direction for *memory* if the
+   cache bound above proves insufficient. **High.**
 
 ---
 

src/completion/context/override_completion.rs

@@ -312,7 +312,7 @@ pub(crate) fn collect_overridable_properties(
             if own.contains(&lower) || !seen.insert(lower) {
                 continue;
             }
-            results.push((prop.clone(), declaring.clone(), false));
+            results.push(((**prop).clone(), declaring.clone(), false));
         }
         let mut collector = PropertyCollector {
             partial,
@@ -384,7 +384,7 @@ impl PropertyCollector<'_> {
                 continue;
             }
             self.results
-                .push((prop.clone(), declaring.clone(), self.skip_override_attr));
+                .push(((**prop).clone(), declaring.clone(), self.skip_override_attr));
         }
     }
 }
@@ -428,7 +428,7 @@ pub(crate) fn collect_overridable_constants(
             if own.contains(&lower) || !seen.insert(lower) {
                 continue;
             }
-            results.push((c.clone(), declaring.clone()));
+            results.push(((**c).clone(), declaring.clone()));
         }
         parent_name = parent.parent_class;
         depth += 1;
@@ -949,7 +949,7 @@ mod tests {
     fn collects_parent_constants() {
         let mut base = make_class("Base");
         base.constants = vec![
-            ConstantInfo {
+            Arc::new(ConstantInfo {
                 name: atom("STATUS_OK"),
                 name_offset: 0,
                 type_hint: None,
@@ -962,8 +962,8 @@ mod tests {
                 enum_value: None,
                 value: Some("1".into()),
                 is_virtual: false,
-            },
-            ConstantInfo {
+            }),
+            Arc::new(ConstantInfo {
                 name: atom("SECRET"),
                 name_offset: 0,
                 type_hint: None,
@@ -976,7 +976,7 @@ mod tests {
                 enum_value: None,
                 value: None,
                 is_virtual: false,
-            },
+            }),
         ]
         .into();
 

src/hover/class.rs

@@ -157,7 +157,12 @@ const MAX_BODY_ITEMS: usize = 30;
 /// If there are more than [`MAX_BODY_ITEMS`] cases, the list is truncated
 /// with a `// and N more…` comment.
 fn build_enum_case_body(cls: &ClassInfo) -> String {
-    let cases: Vec<&ConstantInfo> = cls.constants.iter().filter(|c| c.is_enum_case).collect();
+    let cases: Vec<&ConstantInfo> = cls
+        .constants
+        .iter()
+        .filter(|c| c.is_enum_case)
+        .map(|c| c.as_ref())
+        .collect();
 
     if cases.is_empty() {
         return String::new();

src/hover/member.rs

@@ -446,10 +446,10 @@ impl Backend {
                 .get_method_ci(member_name)
                 .map(|m| HoverMemberHit::Method(Box::new(m.clone())))
         } else {
-            if let Some(prop) = class.properties.iter().find(|p| p.name == member_name) {
+            if let Some(prop) = class.get_property(member_name) {
                 return Some(HoverMemberHit::Property(Box::new(prop.clone())));
             }
-            if let Some(constant) = class.constants.iter().find(|c| c.name == member_name) {
+            if let Some(constant) = class.get_constant(member_name) {
                 return Some(HoverMemberHit::Constant(Box::new(constant.clone())));
             }
             class

src/inheritance/enrichment.rs

@@ -327,6 +327,38 @@ pub(crate) fn enrich_single_parameter(
 /// Propagates type hints and descriptions from the ancestor when the
 /// child lacks its own docblock overrides.  The same
 /// effective-vs-native comparison is used as for method return types.
+/// Copy-on-write wrapper around [`enrich_property_from_ancestor`].
+///
+/// The property analogue of [`enrich_method_arc_from_ancestor`]: the
+/// shared `Arc<PropertyInfo>` is only deep-cloned when the enrichment
+/// would actually change a field, which keeps inherited properties
+/// sharing their allocation in the common no-op case.
+pub(crate) fn enrich_property_arc_from_ancestor(
+    existing: &mut Arc<PropertyInfo>,
+    ancestor: &PropertyInfo,
+) {
+    if property_enrichment_would_change(existing, ancestor) {
+        enrich_property_from_ancestor(Arc::make_mut(existing), ancestor);
+    }
+}
+
+/// Whether [`enrich_property_from_ancestor`] would change any field of
+/// `existing`.  Mirrors the apply function's conditions exactly (keep the
+/// two in sync); an overwrite with an equal value counts as "no change".
+fn property_enrichment_would_change(existing: &PropertyInfo, ancestor: &PropertyInfo) -> bool {
+    // Type hint.
+    if (existing.type_hint.is_none() && ancestor.type_hint.is_some()
+        || lacks_docblock_override(&existing.type_hint, &existing.native_type_hint)
+            && ancestor_has_richer_type(&ancestor.type_hint, &ancestor.native_type_hint))
+        && existing.type_hint != ancestor.type_hint
+    {
+        return true;
+    }
+
+    // Description.
+    existing.description.is_none() && ancestor.description.is_some()
+}
+
 pub(crate) fn enrich_property_from_ancestor(existing: &mut PropertyInfo, ancestor: &PropertyInfo) {
     // ── Type hint ───────────────────────────────────────────────
     // Same logic as method return types: propagate when the child

src/inheritance/generics.rs

@@ -393,9 +393,16 @@ pub(crate) fn apply_generic_args(class: &ClassInfo, type_args: &[PhpType]) -> Cl
         .iter()
         .any(|p| property_references_params(p, &sub_keys))
     {
+        let fp = crate::virtual_members::TransformFingerprint::new(Some(&subs), None, 0);
         for property in result.properties.make_mut() {
             if property_references_params(property, &sub_keys) {
-                apply_substitution_to_property(property, &subs);
+                let transformed =
+                    crate::virtual_members::intern_transformed_property(property, fp, || {
+                        let mut p = (**property).clone();
+                        apply_substitution_to_property(&mut p, &subs);
+                        p
+                    });
+                *property = transformed;
             }
         }
     }

src/inheritance/mod.rs

@@ -27,11 +27,13 @@ use std::sync::Arc;
 use crate::atom::{Atom, AtomSet, atom};
 use crate::php_type::PhpType;
 use crate::types::{ClassInfo, MAX_INHERITANCE_DEPTH, Visibility};
-use crate::virtual_members::{TransformFingerprint, intern_transformed_method};
+use crate::virtual_members::{
+    TransformFingerprint, intern_transformed_method, intern_transformed_property,
+};
 
 // Re-export functions that are used internally
 pub(crate) use enrichment::enrich_method_arc_from_ancestor;
-pub(crate) use enrichment::enrich_property_from_ancestor;
+pub(crate) use enrichment::enrich_property_arc_from_ancestor;
 
 #[cfg(test)]
 pub(crate) use generics::apply_substitution;
@@ -405,15 +407,16 @@ pub(crate) fn resolve_class_with_inheritance(
             merged.methods.push(transformed);
         }
 
-        // Merge parent properties — same enrichment logic.
+        // Merge parent properties — same enrichment logic as methods.
+        // The substitution transform reuses `fp_sub` (a property and a
+        // method with the same substitution map fingerprint to the same
+        // value, but they intern into separate maps keyed by origin type,
+        // so there is no collision).
         for property in &parent.properties {
             if property.visibility == Visibility::Private {
                 continue;
             }
-            let mut ancestor_property = property.clone();
-            if property_references_params(property, &sub_keys) {
-                apply_substitution_to_property(&mut ancestor_property, &level_subs);
-            }
+            let needs_sub = property_references_params(property, &sub_keys);
             if !dedup.properties.insert(property.name) {
                 // Child already has this property — enrich it from parent.
                 if let Some(existing) = merged
@@ -422,22 +425,44 @@ pub(crate) fn resolve_class_with_inheritance(
                     .iter_mut()
                     .find(|p| p.name == property.name)
                 {
-                    enrich_property_from_ancestor(existing, &ancestor_property);
+                    if needs_sub {
+                        let ancestor_property =
+                            intern_transformed_property(property, fp_sub, || {
+                                let mut p = (**property).clone();
+                                apply_substitution_to_property(&mut p, &level_subs);
+                                p
+                            });
+                        enrich_property_arc_from_ancestor(existing, &ancestor_property);
+                    } else {
+                        enrich_property_arc_from_ancestor(existing, property);
+                    }
                 }
                 continue;
             }
-            merged.properties.push(ancestor_property);
+            if !needs_sub {
+                // Substitution is a no-op: keep the shared `Arc`.
+                merged.properties.push(Arc::clone(property));
+                continue;
+            }
+            let transformed = intern_transformed_property(property, fp_sub, || {
+                let mut p = (**property).clone();
+                apply_substitution_to_property(&mut p, &level_subs);
+                p
+            });
+            merged.properties.push(transformed);
         }
 
-        // Merge parent constants
+        // Merge parent constants.  Constants are never transformed on
+        // inheritance, so an inherited constant is always a plain
+        // `Arc::clone` of the declaring class's.
         for constant in &parent.constants {
             if constant.visibility == Visibility::Private {
                 continue;
             }
             if !dedup.constants.insert(constant.name) {
                 continue;
             }
-            merged.constants.push(constant.clone());
+            merged.constants.push(Arc::clone(constant));
         }
 
         // Carry the substitution map forward for the next level.
@@ -501,7 +526,7 @@ pub(crate) fn resolve_class_with_inheritance(
             .iter_mut()
             .find(|p| p.name == "value")
         {
-            prop.type_hint = Some(specific_type);
+            Arc::make_mut(prop).type_hint = Some(specific_type);
         }
     }
 

src/inheritance/traits.rs

@@ -14,11 +14,13 @@ use crate::util::short_name;
 use crate::virtual_members::laravel::{
     extends_eloquent_model, is_has_factory_trait, model_to_factory_fqn,
 };
-use crate::virtual_members::{TransformFingerprint, intern_transformed_method};
+use crate::virtual_members::{
+    TransformFingerprint, intern_transformed_method, intern_transformed_property,
+};
 
 use super::generics::{
     apply_substitution_to_method, apply_substitution_to_property, method_references_params,
-    right_align_offset,
+    property_references_params, right_align_offset,
 };
 use super::{MergeDedup, TraitContext};
 
@@ -175,7 +177,7 @@ pub(crate) fn merge_traits_into(
                 if !dedup.properties.insert(property.name) {
                     continue;
                 }
-                merged.properties.push(property.clone());
+                merged.properties.push(Arc::clone(property));
             }
 
             // Merge parent constants
@@ -186,7 +188,7 @@ pub(crate) fn merge_traits_into(
                 if !dedup.constants.insert(constant.name) {
                     continue;
                 }
-                merged.constants.push(constant.clone());
+                merged.constants.push(Arc::clone(constant));
             }
 
             current = parent;
@@ -288,24 +290,30 @@ pub(crate) fn merge_traits_into(
             }
         }
 
-        // Merge trait properties — apply substitution.
+        // Merge trait properties — apply substitution, sharing the `Arc`
+        // (or the interned transformed copy) as the method loop does.
         for property in &trait_info.properties {
             if !dedup.properties.insert(property.name) {
                 continue;
             }
-            let mut property = property.clone();
-            if !trait_subs.is_empty() {
-                apply_substitution_to_property(&mut property, &trait_subs);
+            if !property_references_params(property, &sub_keys) {
+                merged.properties.push(Arc::clone(property));
+                continue;
             }
-            merged.properties.push(property);
+            let transformed = intern_transformed_property(property, fp_sub, || {
+                let mut p = (**property).clone();
+                apply_substitution_to_property(&mut p, &trait_subs);
+                p
+            });
+            merged.properties.push(transformed);
         }
 
-        // Merge trait constants
+        // Merge trait constants — never transformed, plain `Arc::clone`.
         for constant in &trait_info.constants {
             if !dedup.constants.insert(constant.name) {
                 continue;
             }
-            merged.constants.push(constant.clone());
+            merged.constants.push(Arc::clone(constant));
         }
 
         // Apply `as` alias declarations that create new method names.

src/parser/anonymous.rs

@@ -77,8 +77,16 @@ impl Backend {
             kind: ClassLikeKind::Class,
             name,
             methods: methods.into_iter().map(Arc::new).collect::<Vec<_>>().into(),
-            properties: properties.into(),
-            constants: constants.into(),
+            properties: properties
+                .into_iter()
+                .map(Arc::new)
+                .collect::<Vec<_>>()
+                .into(),
+            constants: constants
+                .into_iter()
+                .map(Arc::new)
+                .collect::<Vec<_>>()
+                .into(),
             start_offset,
             end_offset,
             keyword_offset,