feat: suggest trait member overrides in completion

Typing a method or property name in a class body that uses a trait
now suggests the trait's public and protected members as candidates,
matching the existing override completion for parent classes and
interfaces.

Trait method replacements intentionally omit #[\Override] because
PHP treats trait methods as copied into the class — adding the
attribute on a trait-only method is a compile error. The completion
detail shows 'trait' instead of 'override' to reflect this.

Previously, classes that only used traits (no parent class, no
interfaces) received no override suggestions at all because the
handler bailed out early. That guard now also checks used_traits.

Closes #276

Author: calebdw

docs/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **`@phpstan-ignore` identifiers are highlighted and completed.** PHPStan ignore comments now highlight the `@phpstan-ignore` tag and each listed error identifier in both docblocks and ordinary `//` comments. Identifier completion works inside the comma-separated ignore list, using PHPStan diagnostic codes already seen in the current file while staying out of per-code parenthesized reasons. Contributed by @calebdw.
 - **Parent member override completion.** Typing a method name after `function` in a class body (for example `protected function get`) now suggests public and protected methods from parent classes and interfaces that can still be overridden or implemented, inserting a full signature snippet. The same flow suggests parent properties after `$` (for example `protected $tit`) and parent constants after `const`. Snippets insert `#[\Override]` above methods on PHP 8.3+, properties on PHP 8.5+, and constants on PHP 8.6+ (from `composer.json` / `config.platform.php`). Private members and ones already defined on the class are omitted. Contributed by @calebdw.
+- **Trait member override completion.** Typing a method or property name after `function` or `$` in a class that uses a trait now suggests the trait's public and protected members as override candidates. Unlike parent/interface overrides, trait method replacements do not insert `#[\Override]` (which would be a compile error for trait-only methods). Classes that only use traits without extending a parent or implementing an interface also receive suggestions. Contributed by @calebdw.
 - **Laravel schema dumps power Eloquent model properties.** PHPantom now scans Laravel database schema dumps from `database/schema` by default, reads `config/database.php` for connection drivers/defaults, and uses the parsed columns to synthesize Eloquent model properties with database types, nullability, and defaults in hover. Schema lookup respects model `$connection`, `$table`, Laravel `Connection`/`Table` attributes, dynamic table/connection overrides, and reloads when schema files or related config change. Contributed by @calebdw.
 - **Laravel migration scanning for Eloquent model properties.** PHPantom now parses Laravel migration files to infer database columns when schema dumps are not available or to overlay changes on top of dumps. Migrations are discovered from any non-vendor `database/migrations` directory (including nested modules like `modules/billing/database/migrations`), applied in global filename order, and support named and anonymous migration classes, `$connection` properties, `Schema::connection()` calls, `Blueprint::after()` nested closures, `virtualAs`/`storedAs` generated columns, and custom Blueprint macros registered via the existing macro scanner. Migration scanning is incremental: editing a single migration re-reads only that file and replays the cached plan over the base schema without re-reading other files. Configure with `[laravel.migrations] enabled` and `paths` in `.phpantom.toml`. Contributed by @calebdw.
 - **By-reference closure captures update outer variable types for immediately-invoked callables.** A closure passed to a callable parameter can now update the inferred type of variables captured with `use (&$var)` when the callable is considered immediately invoked. This follows PHPStan's defaults: function callable parameters are immediate unless marked with `@param-later-invoked-callable`, while method callable parameters are later-invoked unless marked with `@param-immediately-invoked-callable`. Contributed by @calebdw.

src/completion/context/override_completion.rs

@@ -32,23 +32,25 @@ const METHOD_OVERRIDE_ATTR_MIN: PhpVersion = PhpVersion::new(8, 3);
 const PROPERTY_OVERRIDE_ATTR_MIN: PhpVersion = PhpVersion::new(8, 5);
 const CONSTANT_OVERRIDE_ATTR_MIN: PhpVersion = PhpVersion::new(8, 6);
 
-/// Collect public/protected methods from parents and interfaces that the
-/// current class can still override or implement.
+/// Collect public/protected methods from parents, interfaces, and
+/// directly-used traits that the current class can still override or
+/// implement.
+///
+/// The returned bool (`skip_override_attr`) is `true` for methods that
+/// come from a directly-used trait (where `#[\Override]` would be a
+/// compile error) and `false` for parent/interface methods.
 pub(crate) fn collect_overridable_methods(
     class: &ClassInfo,
     partial: &str,
     class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
-) -> Vec<(MethodInfo, String)> {
-    let mut own_names: HashSet<String> = class
+) -> Vec<(MethodInfo, String, bool)> {
+    let own_names: HashSet<String> = class
         .methods
         .iter()
         .map(|m| m.name.to_lowercase())
         .collect();
 
-    // Trait methods already on this class count as implemented.
-    collect_trait_method_names(&class.used_traits, class_loader, &mut own_names, 0);
-
-    let mut results: Vec<(MethodInfo, String)> = Vec::new();
+    let mut results: Vec<(MethodInfo, String, bool)> = Vec::new();
     let mut seen: HashSet<String> = HashSet::new();
     let mut visited: HashSet<String> = HashSet::new();
 
@@ -59,6 +61,7 @@ pub(crate) fn collect_overridable_methods(
         seen: &mut seen,
         visited: &mut visited,
         results: &mut results,
+        skip_override_attr: false,
     };
 
     collector.collect_from_parent_chain(&class.parent_class, 0);
@@ -74,27 +77,10 @@ pub(crate) fn collect_overridable_methods(
         collector.collect_from_interface(iface, 0);
     }
 
-    results
-}
+    collector.skip_override_attr = true;
+    collector.collect_from_traits(&class.used_traits, 0);
 
-fn collect_trait_method_names(
-    traits: &[crate::atom::Atom],
-    class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
-    names: &mut HashSet<String>,
-    depth: usize,
-) {
-    if depth > crate::types::MAX_INHERITANCE_DEPTH as usize {
-        return;
-    }
-    for tname in traits {
-        let Some(tr) = class_loader(tname) else {
-            continue;
-        };
-        for m in &tr.methods {
-            names.insert(m.name.to_lowercase());
-        }
-        collect_trait_method_names(&tr.used_traits, class_loader, names, depth + 1);
-    }
+    results
 }
 
 struct MethodCollector<'a> {
@@ -103,7 +89,8 @@ struct MethodCollector<'a> {
     own_names: &'a HashSet<String>,
     seen: &'a mut HashSet<String>,
     visited: &'a mut HashSet<String>,
-    results: &'a mut Vec<(MethodInfo, String)>,
+    results: &'a mut Vec<(MethodInfo, String, bool)>,
+    skip_override_attr: bool,
 }
 
 impl MethodCollector<'_> {
@@ -184,7 +171,11 @@ impl MethodCollector<'_> {
             if self.own_names.contains(&lower) || !self.seen.insert(lower) {
                 continue;
             }
-            self.results.push(((**method).clone(), declaring.clone()));
+            self.results.push((
+                (**method).clone(),
+                declaring.clone(),
+                self.skip_override_attr,
+            ));
         }
     }
 }
@@ -204,14 +195,10 @@ pub(crate) struct OverrideCompletionOpts<'a> {
 /// When `php_version >= 8.3`, each item also inserts `#[\Override]` on the
 /// line above the declaration via `additional_text_edits`.
 pub(crate) fn build_override_completions(
-    methods: &[(MethodInfo, String)],
+    methods: &[(MethodInfo, String, bool)],
     opts: &OverrideCompletionOpts<'_>,
 ) -> Vec<CompletionItem> {
-    let add_override = opts.php_version >= METHOD_OVERRIDE_ATTR_MIN;
-    // Insert the attribute at the start of the declaration line.  The
-    // indent is included here because this edit is at column 0 of the
-    // line (absolute), not mid-line like the name snippet.
-    let override_edit = if add_override {
+    let override_edit = if opts.php_version >= METHOD_OVERRIDE_ATTR_MIN {
         Some(TextEdit {
             range: Range {
                 start: opts.line_start,
@@ -224,7 +211,7 @@ pub(crate) fn build_override_completions(
     };
 
     let mut items = Vec::new();
-    for (method, declaring) in methods {
+    for (method, declaring, skip_override_attr) in methods {
         let params = format_params(method, opts.use_map, opts.file_namespace);
         let return_type = format_return_type(method, opts.use_map, opts.file_namespace);
         let label = if return_type.is_empty() {
@@ -249,12 +236,17 @@ pub(crate) fn build_override_completions(
         );
 
         let sort_prefix = if method.is_abstract { "0" } else { "1" };
+        let detail_kind = if *skip_override_attr {
+            "trait"
+        } else {
+            "override"
+        };
         let sort_text = format!("{sort_prefix}_{}", method.name.to_ascii_lowercase());
 
         items.push(CompletionItem {
             label: label.clone(),
             kind: Some(CompletionItemKind::METHOD),
-            detail: Some(format!("override · {}", short_name(declaring))),
+            detail: Some(format!("{detail_kind} · {}", short_name(declaring))),
             filter_text: Some(method.name.to_string()),
             sort_text: Some(sort_text),
             insert_text: Some(insert_text.clone()),
@@ -263,7 +255,11 @@ pub(crate) fn build_override_completions(
                 range: opts.replace_range,
                 new_text: insert_text,
             })),
-            additional_text_edits: override_edit.clone().map(|e| vec![e]),
+            additional_text_edits: if *skip_override_attr {
+                None
+            } else {
+                override_edit.clone().map(|e| vec![e])
+            },
             label_details: Some(CompletionItemLabelDetails {
                 detail: None,
                 description: Some(short_name(declaring).to_string()),
@@ -282,13 +278,12 @@ pub(crate) fn collect_overridable_properties(
     class: &ClassInfo,
     partial: &str,
     class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
-) -> Vec<(PropertyInfo, String)> {
-    let mut own: HashSet<String> = class
+) -> Vec<(PropertyInfo, String, bool)> {
+    let own: HashSet<String> = class
         .properties
         .iter()
         .map(|p| p.name.to_lowercase())
         .collect();
-    collect_trait_property_names(&class.used_traits, class_loader, &mut own, 0);
 
     let mut results = Vec::new();
     let mut seen = HashSet::new();
@@ -317,7 +312,7 @@ pub(crate) fn collect_overridable_properties(
             if own.contains(&lower) || !seen.insert(lower) {
                 continue;
             }
-            results.push((prop.clone(), declaring.clone()));
+            results.push((prop.clone(), declaring.clone(), false));
         }
         let mut collector = PropertyCollector {
             partial,
@@ -326,32 +321,25 @@ pub(crate) fn collect_overridable_properties(
             seen: &mut seen,
             visited: &mut visited,
             results: &mut results,
+            skip_override_attr: false,
         };
         collector.collect_from_traits(&parent.used_traits, depth + 1);
         parent_name = parent.parent_class;
         depth += 1;
     }
-    results
-}
 
-fn collect_trait_property_names(
-    traits: &[crate::atom::Atom],
-    class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
-    names: &mut HashSet<String>,
-    depth: usize,
-) {
-    if depth > crate::types::MAX_INHERITANCE_DEPTH as usize {
-        return;
-    }
-    for tname in traits {
-        let Some(tr) = class_loader(tname) else {
-            continue;
-        };
-        for p in &tr.properties {
-            names.insert(p.name.to_lowercase());
-        }
-        collect_trait_property_names(&tr.used_traits, class_loader, names, depth + 1);
-    }
+    let mut collector = PropertyCollector {
+        partial,
+        class_loader,
+        own: &own,
+        seen: &mut seen,
+        visited: &mut visited,
+        results: &mut results,
+        skip_override_attr: true,
+    };
+    collector.collect_from_traits(&class.used_traits, 0);
+
+    results
 }
 
 struct PropertyCollector<'a> {
@@ -360,7 +348,8 @@ struct PropertyCollector<'a> {
     own: &'a HashSet<String>,
     seen: &'a mut HashSet<String>,
     visited: &'a mut HashSet<String>,
-    results: &'a mut Vec<(PropertyInfo, String)>,
+    results: &'a mut Vec<(PropertyInfo, String, bool)>,
+    skip_override_attr: bool,
 }
 
 impl PropertyCollector<'_> {
@@ -394,7 +383,8 @@ impl PropertyCollector<'_> {
             if self.own.contains(&lower) || !self.seen.insert(lower) {
                 continue;
             }
-            self.results.push((prop.clone(), declaring.clone()));
+            self.results
+                .push((prop.clone(), declaring.clone(), self.skip_override_attr));
         }
     }
 }
@@ -451,7 +441,7 @@ pub(crate) fn collect_overridable_constants(
 /// Inserts `name = default` when the parent has an initializer so the
 /// user can override `protected $attributes = []` style members in one go.
 pub(crate) fn build_property_override_completions(
-    props: &[(PropertyInfo, String)],
+    props: &[(PropertyInfo, String, bool)],
     opts: &NameOverrideCompletionOpts<'_>,
 ) -> Vec<CompletionItem> {
     let override_edit = if opts.php_version >= PROPERTY_OVERRIDE_ATTR_MIN {
@@ -466,7 +456,7 @@ pub(crate) fn build_property_override_completions(
         None
     };
     let mut items = Vec::new();
-    for (prop, declaring) in props {
+    for (prop, declaring, skip_override_attr) in props {
         let type_str = prop
             .native_type_hint
             .as_ref()
@@ -484,18 +474,27 @@ pub(crate) fn build_property_override_completions(
             (None, Some(d)) => format!("${} = {}", prop.name, d),
             (None, None) => format!("${}", prop.name),
         };
+        let detail_kind = if *skip_override_attr {
+            "trait"
+        } else {
+            "override"
+        };
         items.push(CompletionItem {
             label,
             kind: Some(CompletionItemKind::PROPERTY),
-            detail: Some(format!("override · {}", short_name(declaring))),
+            detail: Some(format!("{detail_kind} · {}", short_name(declaring))),
             filter_text: Some(prop.name.to_string()),
             sort_text: Some(format!("0_{}", prop.name.to_ascii_lowercase())),
             insert_text: Some(insert.clone()),
             text_edit: Some(CompletionTextEdit::Edit(TextEdit {
                 range: opts.replace_range,
                 new_text: insert,
             })),
-            additional_text_edits: override_edit.clone().map(|e| vec![e]),
+            additional_text_edits: if *skip_override_attr {
+                None
+            } else {
+                override_edit.clone().map(|e| vec![e])
+            },
             label_details: Some(CompletionItemLabelDetails {
                 detail: None,
                 description: Some(short_name(declaring).to_string()),

src/completion/handler/member_access.rs

@@ -322,7 +322,10 @@ impl Backend {
         ) {
             return None;
         }
-        if class.parent_class.is_none() && class.interfaces.is_empty() {
+        if class.parent_class.is_none()
+            && class.interfaces.is_empty()
+            && class.used_traits.is_empty()
+        {
             return None;
         }