Fix interface-extends-interface constants

Author: AJenbo

docs/todo/bugs.md

@@ -77,38 +77,6 @@ completion.
 
 ---
 
-#### B12. Interface-extends-interface constants (and other members) not merged
-
-| | |
-|---|---|
-| **Impact** | Low-Medium |
-| **Effort** | Low-Medium |
-
-When an interface extends multiple parent interfaces (e.g.
-`interface CarbonInterface extends DateTimeInterface, JsonSerializable, UnitValue`),
-`resolve_class_with_inheritance` only walks the `parent_class` field (the
-first extended interface). The remaining parent interfaces stored in the
-`interfaces` list are not traversed for member merging.
-
-Then `resolve_class_fully_inner` calls `resolve_class_with_inheritance` on
-each interface collected from the class, but that inner call has the same
-limitation — it does not recurse into the interface's own `interfaces` list.
-
-**Reproducer:** `Illuminate\Support\Carbon::JANUARY` — the `JANUARY` constant
-lives on `Carbon\Constants\UnitValue`, which `CarbonInterface` extends (6th
-in the extends list). PHPantom reports "Member 'JANUARY' not found on class
-'Illuminate\Support\Carbon'".
-
-**Fix:** In `resolve_class_with_inheritance`, when processing an interface
-(or always), also merge members from all entries in `self.interfaces`, not
-just `parent_class`. Alternatively, make `resolve_class_fully_inner`
-recursively collect parent interfaces when resolving each interface.
-
-Affects 4 diagnostics in shared (Carbon month constants) and likely more in
-other projects that use interfaces with multi-extends chains.
-
----
-
 #### B13. Variable type resolved from reassignment target inside RHS expression
 
 | | |

src/virtual_members/mod.rs

@@ -738,14 +738,45 @@ fn resolve_class_fully_inner(
         }
     }
 
-    for iface_name in &all_iface_names {
-        if let Some(iface) = class_loader(iface_name) {
+    // Use an index-based loop so that we can grow `all_iface_names`
+    // while iterating — each resolved interface may itself extend
+    // additional interfaces that need to be collected transitively.
+    let mut iface_idx = 0;
+    while iface_idx < all_iface_names.len() {
+        let iface_name = all_iface_names[iface_idx].clone();
+        iface_idx += 1;
+
+        if let Some(iface) = class_loader(&iface_name) {
+            // Collect interfaces that this interface itself extends.
+            // For example, CarbonInterface extends DateTimeInterface,
+            // JsonSerializable, UnitValue — all of those need to be
+            // resolved and their members merged transitively.
+            for child_iface in &iface.interfaces {
+                if !all_iface_names.contains(child_iface) {
+                    all_iface_names.push(child_iface.clone());
+                }
+            }
+
+            // Collect @extends / @implements generics from the
+            // interface so that template substitutions flow through
+            // transitive interface chains.
+            for (name, args) in &iface.extends_generics {
+                if !all_implements_generics.iter().any(|(n, _)| n == name) {
+                    all_implements_generics.push((name.clone(), args.clone()));
+                }
+            }
+            for (name, args) in &iface.implements_generics {
+                if !all_implements_generics.iter().any(|(n, _)| n == name) {
+                    all_implements_generics.push((name.clone(), args.clone()));
+                }
+            }
+
             // Build a substitution map from `@implements` generics for
             // this interface.  If the class (or a parent) declared
             // `@implements ThisInterface<Type1, Type2>`, map the
             // interface's template params to those concrete types.
             let iface_subs =
-                build_implements_substitution_map(iface_name, &iface, &all_implements_generics);
+                build_implements_substitution_map(&iface_name, &iface, &all_implements_generics);
 
             // When we have substitutions to apply, we cannot use a
             // cached bare-interface resolution because the cached version

src/virtual_members/tests.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::test_fixtures::{make_class, make_method, make_property};
-use crate::types::Visibility;
+use crate::types::{ClassLikeKind, ConstantInfo, Visibility};
 use std::sync::Arc;
 
 // ── VirtualMembers tests ────────────────────────────────────────────
@@ -1186,3 +1186,90 @@ fn evict_cast_class_chains_through_model_to_child() {
         "cast eviction should chain: cast → model (via casts) → child (via parent)"
     );
 }
+
+// ── B12: interface-extends-interface transitive member merging ───────
+
+#[test]
+fn resolve_class_fully_merges_transitive_interface_constants() {
+    // Simulates the Carbon scenario:
+    //   interface UnitValue       { const JANUARY = 1; }
+    //   interface JsonSerializable { function jsonSerialize(): mixed; }
+    //   interface DateTimeInterface { function format(string $f): string; }
+    //   interface CarbonInterface extends DateTimeInterface, JsonSerializable, UnitValue {}
+    //   class Carbon implements CarbonInterface {}
+    //
+    // Before the fix, only DateTimeInterface (the first extended
+    // interface, stored in `parent_class`) was merged.  Members from
+    // JsonSerializable and UnitValue were lost.
+
+    let mut unit_value = make_class("Carbon\\Constants\\UnitValue");
+    unit_value.kind = ClassLikeKind::Interface;
+    unit_value.constants.push(ConstantInfo {
+        name: "JANUARY".to_string(),
+        name_offset: 0,
+        type_hint: Some("int".to_string()),
+        visibility: Visibility::Public,
+        deprecation_message: None,
+        deprecated_replacement: None,
+        see_refs: Vec::new(),
+        description: None,
+        is_enum_case: false,
+        enum_value: None,
+        value: Some("1".to_string()),
+        is_virtual: false,
+    });
+
+    let mut json_serializable = make_class("JsonSerializable");
+    json_serializable.kind = ClassLikeKind::Interface;
+    json_serializable
+        .methods
+        .push(make_method("jsonSerialize", Some("mixed")));
+
+    let mut datetime_iface = make_class("DateTimeInterface");
+    datetime_iface.kind = ClassLikeKind::Interface;
+    datetime_iface
+        .methods
+        .push(make_method("format", Some("string")));
+
+    let mut carbon_iface = make_class("CarbonInterface");
+    carbon_iface.kind = ClassLikeKind::Interface;
+    carbon_iface.parent_class = Some("DateTimeInterface".to_string());
+    carbon_iface.interfaces = vec![
+        "DateTimeInterface".to_string(),
+        "JsonSerializable".to_string(),
+        "Carbon\\Constants\\UnitValue".to_string(),
+    ];
+
+    let mut carbon = make_class("Carbon");
+    carbon.interfaces = vec!["CarbonInterface".to_string()];
+
+    let class_loader = move |name: &str| -> Option<Arc<ClassInfo>> {
+        match name {
+            "CarbonInterface" => Some(Arc::new(carbon_iface.clone())),
+            "DateTimeInterface" => Some(Arc::new(datetime_iface.clone())),
+            "JsonSerializable" => Some(Arc::new(json_serializable.clone())),
+            "Carbon\\Constants\\UnitValue" => Some(Arc::new(unit_value.clone())),
+            _ => None,
+        }
+    };
+
+    let resolved = crate::virtual_members::resolve_class_fully(&carbon, &class_loader);
+
+    // DateTimeInterface::format — merged via CarbonInterface's parent_class chain
+    assert!(
+        resolved.methods.iter().any(|m| m.name == "format"),
+        "should have DateTimeInterface::format"
+    );
+
+    // JsonSerializable::jsonSerialize — merged via transitive interface collection
+    assert!(
+        resolved.methods.iter().any(|m| m.name == "jsonSerialize"),
+        "should have JsonSerializable::jsonSerialize (2nd extended interface)"
+    );
+
+    // UnitValue::JANUARY — merged via transitive interface collection
+    assert!(
+        resolved.constants.iter().any(|c| c.name == "JANUARY"),
+        "should have UnitValue::JANUARY constant (3rd extended interface)"
+    );
+}