perf(codex): remove potential_declaring_method_ids

Signed-off-by: azjezz <[email protected]>

Author: azjezz

crates/codex/src/metadata/class_like.rs

@@ -64,7 +64,6 @@ pub struct ClassLikeMetadata {
     pub appearing_method_ids: AtomMap<MethodIdentifier>,
     pub inheritable_method_ids: AtomMap<MethodIdentifier>,
     pub overridden_method_ids: AtomMap<HashMap<Atom, MethodIdentifier>>,
-    pub potential_declaring_method_ids: AtomMap<HashMap<String, bool>>,
     pub properties: AtomMap<PropertyMetadata>,
     pub appearing_property_ids: AtomMap<Atom>,
     pub declaring_property_ids: AtomMap<Atom>,
@@ -125,7 +124,6 @@ impl ClassLikeMetadata {
             static_pseudo_methods: AtomSet::default(),
             overridden_method_ids: AtomMap::default(),
             overridden_property_ids: AtomMap::default(),
-            potential_declaring_method_ids: AtomMap::default(),
             properties: AtomMap::default(),
             template_variance: HashMap::default(),
             template_type_extends_count: AtomMap::default(),
@@ -209,12 +207,6 @@ impl ClassLikeMetadata {
         self.appearing_method_ids.contains_key(method)
     }
 
-    /// Returns a reference to a specific method's potential declaring method id strings.
-    #[inline]
-    pub fn get_potential_declaring_method_id(&self, method: &Atom) -> Option<&HashMap<String, bool>> {
-        self.potential_declaring_method_ids.get(method)
-    }
-
     /// Returns a vector of property names.
     #[inline]
     pub fn get_property_names(&self) -> AtomSet {
@@ -360,12 +352,6 @@ impl ClassLikeMetadata {
             .insert(*parent_method_id.get_class_name(), parent_method_id)
     }
 
-    /// Adds a potential declaring method id string to the map for a method. Initializes map if needed.
-    #[inline]
-    pub fn add_potential_declaring_method(&mut self, method: Atom, potential_method_id_str: String) {
-        self.potential_declaring_method_ids.entry(method).or_default().insert(potential_method_id_str, true);
-    }
-
     /// Adds or updates a property's metadata. Returns the previous metadata if the property existed.
     #[inline]
     pub fn add_property(&mut self, name: Atom, property_metadata: PropertyMetadata) -> Option<PropertyMetadata> {
@@ -472,7 +458,6 @@ impl ClassLikeMetadata {
         self.declaring_method_ids.shrink_to_fit();
         self.inheritable_method_ids.shrink_to_fit();
         self.overridden_method_ids.shrink_to_fit();
-        self.potential_declaring_method_ids.shrink_to_fit();
         self.attributes.shrink_to_fit();
         self.constants.shrink_to_fit();
         self.enum_cases.shrink_to_fit();

crates/codex/src/populator/methods.rs

@@ -1,4 +1,5 @@
 use ahash::HashMap;
+use mago_atom::Atom;
 use mago_atom::atom;
 
 use crate::identifier::method::MethodIdentifier;
@@ -15,21 +16,24 @@ pub fn inherit_methods_from_parent(
     let class_like_name = metadata.name;
     let parent_is_trait = parent_metadata.kind.is_trait();
 
-    // Register where methods appear (can never be in a trait in the final appearing_method_ids)
+    let reverse_alias_map: Option<HashMap<Atom, Vec<Atom>>> = if parent_is_trait && !metadata.trait_alias_map.is_empty()
+    {
+        let mut map: HashMap<Atom, Vec<Atom>> = HashMap::default();
+        for (original, alias) in metadata.get_trait_alias_map().iter() {
+            map.entry(*original).or_default().push(*alias);
+        }
+        Some(map)
+    } else {
+        None
+    };
+
     for (method_name_lc, appearing_method_id) in &parent_metadata.appearing_method_ids {
-        // Build a list of aliased method names
         let mut aliased_method_names = vec![*method_name_lc];
 
-        if parent_is_trait && !metadata.trait_alias_map.is_empty() {
-            // Find all aliases for this method
-            // trait_alias_map is: original_method_name -> alias_name
-            aliased_method_names.extend(
-                metadata
-                    .get_trait_alias_map()
-                    .iter()
-                    .filter(|(original, _)| *original == method_name_lc)
-                    .map(|(_, alias)| *alias),
-            );
+        if let Some(ref reverse_map) = reverse_alias_map
+            && let Some(aliases) = reverse_map.get(method_name_lc)
+        {
+            aliased_method_names.extend(aliases.iter().copied());
         }
 
         for aliased_method_name in aliased_method_names {
@@ -42,31 +46,9 @@ pub fn inherit_methods_from_parent(
             let final_appearing_id = if parent_is_trait { implemented_method_id } else { *appearing_method_id };
 
             metadata.appearing_method_ids.insert(aliased_method_name, final_appearing_id);
-
-            let this_method_id_str = format!("{}::{}", class_like_name, method_name_lc);
-
-            if codebase.function_likes.contains_key(&(class_like_name, aliased_method_name)) {
-                let mut potential_ids = HashMap::default();
-                potential_ids.insert(this_method_id_str, true);
-                metadata.potential_declaring_method_ids.insert(aliased_method_name, potential_ids);
-            } else {
-                if let Some(parent_potential_method_ids) =
-                    parent_metadata.get_potential_declaring_method_id(&aliased_method_name)
-                {
-                    metadata
-                        .potential_declaring_method_ids
-                        .insert(aliased_method_name, parent_potential_method_ids.clone());
-                }
-
-                metadata.add_potential_declaring_method(aliased_method_name, this_method_id_str);
-
-                let parent_method_id_str = format!("{}::{}", parent_metadata.name, method_name_lc);
-                metadata.add_potential_declaring_method(aliased_method_name, parent_method_id_str);
-            }
         }
     }
 
-    // Register where methods are declared
     for (method_name_lc, declaring_method_id) in &parent_metadata.inheritable_method_ids {
         if !method_name_lc.eq(&atom("__construct")) || parent_metadata.flags.has_consistent_constructor() {
             if parent_is_trait {
@@ -93,15 +75,10 @@ pub fn inherit_methods_from_parent(
 
         let mut aliased_method_names = vec![*method_name_lc];
 
-        if parent_is_trait && !metadata.trait_alias_map.is_empty() {
-            // trait_alias_map is: original_method_name -> alias_name
-            aliased_method_names.extend(
-                metadata
-                    .get_trait_alias_map()
-                    .iter()
-                    .filter(|(original, _)| *original == method_name_lc)
-                    .map(|(_, alias)| *alias),
-            );
+        if let Some(ref reverse_map) = reverse_alias_map
+            && let Some(aliases) = reverse_map.get(method_name_lc)
+        {
+            aliased_method_names.extend(aliases.iter().copied());
         }
 
         for aliased_method_name in aliased_method_names {