feat: infer property types from constructor assignments

Author: lucasacoutinho

docs/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Untyped property type inference from constructor.** Go-to-definition and completion now resolve property types that have no type declaration by inspecting the constructor body for `$this->prop = new ClassName()` assignments and promoted parameter defaults like `private $prop = new ClassName()`. PHPDoc generation also uses the inferred type: typing `/**` above an untyped property produces `@var Repository` instead of `@var mixed` when the constructor assigns `new Repository()`. This covers common patterns in legacy PHP codebases and PHP 8.1+ code using `new` in initializers. Contributed by @lucasacoutinho in https://github.com/AJenbo/phpantom_lsp/pull/81.
 - **PHPCS diagnostic proxy.** PHP_CodeSniffer violations are surfaced as LSP diagnostics. When `squizlabs/php_codesniffer` is in `require-dev`, PHPCS is auto-detected via Composer's bin-dir; otherwise it falls back to `$PATH`. Each violation uses the sniff name as the diagnostic code (e.g. `PSR12.Files.FileHeader.MissingPHPVersion`), maps PHPCS error/warning levels to LSP severity, and marks fixable violations in diagnostic data. Runs in a dedicated background worker with the same debounce and single-pending-URI design as the PHPStan proxy. Configurable under `[phpcs]` in `.phpantom.toml` with `command`, `standard`, and `timeout` options.
 - **Linked editing ranges.** Place the cursor on a variable and all occurrences within its definition region (from one assignment to the next) enter linked editing mode. Typing a new name updates every occurrence simultaneously without affecting reassigned uses of the same variable name. Ranges exclude the leading `$` sigil so that typing before a variable (e.g. wrapping it in a function call) does not propagate to other occurrences.
 - **Invalid class-like kind diagnostics.** Flags class-like names used in positions where their kind is guaranteed to fail at runtime: `new` on abstract classes, interfaces, traits, or enums; `extends` on a final class, interface, or trait; `implements` with a non-interface; trait `use` with a non-trait; `instanceof` with a trait (always false); `catch` with a non-Throwable type or trait; and traits in native type-hint positions. Severity follows PHP semantics: unconditional fatal errors are Error, runtime-conditional failures are Warning.

example.php

@@ -3369,6 +3369,38 @@ private function acceptTrait(JsonSerializer $x): JsonSerializer
 }
 
 
+// ── Untyped Property Inference ──────────────────────────────────────────────
+// Properties without type declarations have their types inferred from
+// constructor assignments (`$this->prop = new Foo()`) and promoted
+// parameter defaults (`private $prop = new Foo()`). Trigger completion
+// after `->` on the property to see methods from the inferred type.
+
+class UntypedPropertyInferenceDemo
+{
+    private $repository;
+    private $logger;
+
+    public function __construct(
+        private $defaultRepo = new ScaffoldingUntypedRepo(),
+    ) {
+        $this->repository = new ScaffoldingUntypedRepo();
+        $this->logger = new ScaffoldingUntypedLogger();
+    }
+
+    public function demo(): void
+    {
+        // Constructor body assignment: $this->repository = new ScaffoldingUntypedRepo()
+        $this->repository->findById(1);       // resolves ScaffoldingUntypedRepo::findById()
+
+        // Constructor body assignment: $this->logger = new ScaffoldingUntypedLogger()
+        $this->logger->info('hello');         // resolves ScaffoldingUntypedLogger::info()
+
+        // Promoted parameter default: private $defaultRepo = new ScaffoldingUntypedRepo()
+        $this->defaultRepo->findById(42);     // resolves ScaffoldingUntypedRepo::findById()
+    }
+}
+
+
 // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 // ┃  SCAFFOLDING — Supporting definitions below this line.              ┃
 
@@ -3437,6 +3469,20 @@ public function map(string $signature, mixed $source): Pen|Marker
 // The same applies to `interface Foo extends \Stringable`.
 
 
+// ── Untyped Property Inference Scaffolding ──────────────────────────────────
+
+class ScaffoldingUntypedRepo
+{
+    public function findById(int $id): Pen { return new Pen('found'); }
+    public function save(Pen $pen): void {}
+}
+
+class ScaffoldingUntypedLogger
+{
+    public function info(string $msg): void {}
+    public function error(string $msg): void {}
+}
+
 // ── Demo-Specific Scaffolding ───────────────────────────────────────────────
 
 // ── Inherited Docblock Scaffolding ──────────────────────────────────────────
@@ -6091,6 +6137,14 @@ function runDemoAssertions(): void
         assert($shapeEntry['tool'] instanceof Pen, 'Shape key from conditional loop must resolve to Pen');
     }
 
+    // ── Untyped property inference from constructor ─────────────────────
+    $untypedDemo = new UntypedPropertyInferenceDemo();
+    // The scaffolding repo's findById() returns Pen, so we can verify
+    // that the inferred type propagates through the property chain.
+    $repoRef = new ScaffoldingUntypedRepo();
+    $found = $repoRef->findById(1);
+    assert($found instanceof Pen, 'ScaffoldingUntypedRepo::findById() must return Pen');
+
     echo "All assertions passed.\n";
 }
 

src/completion/phpdoc/generation.rs

@@ -82,7 +82,13 @@ pub fn try_generate_docblock(
         return None;
     }
 
-    let sym = parse_declaration_info(&remaining);
+    let mut sym = parse_declaration_info(&remaining);
+
+    // For untyped properties, try to fill in the type from the parsed
+    // class data (e.g. constructor-inferred `$this->prop = new Foo()`).
+    if matches!(context, DocblockContext::Property) && sym.type_hint.is_none() {
+        enrich_property_type_from_class(&mut sym, content, position, local_classes);
+    }
 
     let snippet = build_docblock_snippet(
         &context,
@@ -176,7 +182,13 @@ pub fn try_generate_docblock_on_enter(
         return None;
     }
 
-    let sym = parse_declaration_info(&after_block);
+    let mut sym = parse_declaration_info(&after_block);
+
+    // For untyped properties, try to fill in the type from the parsed
+    // class data (e.g. constructor-inferred `$this->prop = new Foo()`).
+    if matches!(context, DocblockContext::Property) && sym.type_hint.is_none() {
+        enrich_property_type_from_class(&mut sym, content, position, local_classes);
+    }
 
     // Build the docblock as plain text (no snippet tab stops).
     let plain = build_docblock_plain(
@@ -846,6 +858,54 @@ fn extract_return_type_from_decl(after_close: &str) -> Option<PhpType> {
 }
 
 /// Extract the type hint from a property or constant declaration.
+/// Enrich an untyped property's [`SymbolInfo::type_hint`] by looking up
+/// the property in the file's parsed class data.
+///
+/// When a property has no native type hint or docblock, the constructor-
+/// inference pass in `extract_class_like_members` may have filled in a
+/// type from `$this->prop = new ClassName()` or a promoted parameter
+/// default.  This function finds that inferred type and copies it into
+/// `sym` so that the generated `@var` tag uses the concrete class name
+/// instead of `mixed`.
+///
+/// The type is shortened (leading namespace segments stripped) for
+/// readability in the generated docblock.
+fn enrich_property_type_from_class(
+    sym: &mut SymbolInfo,
+    content: &str,
+    position: Position,
+    local_classes: &[Arc<ClassInfo>],
+) {
+    // Extract the bare property name (strip the `$` prefix).
+    let prop_name = sym
+        .variable_name
+        .as_ref()
+        .and_then(|v| v.strip_prefix('$'))
+        .unwrap_or("");
+    if prop_name.is_empty() {
+        return;
+    }
+
+    // Find the enclosing class by byte offset.
+    let cursor_offset = position_to_byte_offset(content, position) as u32;
+    let enclosing = local_classes
+        .iter()
+        .find(|cls| cls.start_offset <= cursor_offset && cursor_offset <= cls.end_offset);
+    let Some(cls) = enclosing else {
+        return;
+    };
+
+    // Look up the property.  Only use the type when it was inferred
+    // (the native_type_hint is None — if it were set, the source-text
+    // parser would already have extracted it).
+    if let Some(prop) = cls.properties.iter().find(|p| p.name == prop_name)
+        && prop.native_type_hint.is_none()
+        && let Some(ref inferred) = prop.type_hint
+    {
+        sym.type_hint = Some(inferred.shorten());
+    }
+}
+
 fn extract_property_type(decl: &str) -> Option<PhpType> {
     // Strip modifiers.
     let modifiers = [

src/parser/classes.rs

@@ -1735,13 +1735,43 @@ impl Backend {
         doc_ctx: Option<&DocblockCtx<'a>>,
         class_template_params: &[String],
     ) -> ExtractedMembers {
+        /// Resolve a short class name to its FQN using the file's use-map
+        /// and namespace from [`DocblockCtx`].  When no context is
+        /// available the name is returned as-is.
+        fn resolve_name_via_ctx(name: &str, doc_ctx: Option<&DocblockCtx<'_>>) -> String {
+            // Already fully-qualified — strip the leading `\`.
+            if let Some(stripped) = name.strip_prefix('\\') {
+                return stripped.to_string();
+            }
+            let Some(ctx) = doc_ctx else {
+                return name.to_string();
+            };
+            // Check use-map (handles both unqualified and qualified names).
+            if let Some(pos) = name.find('\\') {
+                let first = &name[..pos];
+                let rest = &name[pos..];
+                if let Some(fqn) = ctx.use_map.get(first) {
+                    return format!("{fqn}{rest}");
+                }
+            } else if let Some(fqn) = ctx.use_map.get(name) {
+                return fqn.clone();
+            }
+            // Prepend current namespace if available.
+            if let Some(ref ns) = ctx.namespace {
+                format!("{ns}\\{name}")
+            } else {
+                name.to_string()
+            }
+        }
+
         let mut methods = Vec::new();
         let mut properties = Vec::new();
         let mut constants = Vec::new();
         let mut used_traits = Vec::new();
         let mut trait_precedences = Vec::new();
         let mut trait_aliases = Vec::new();
         let mut inline_use_generics: Vec<(String, Vec<PhpType>)> = Vec::new();
+        let mut constructor_body: Option<&MethodBody<'_>> = None;
 
         for member in members {
             match member {
@@ -1930,6 +1960,7 @@ impl Backend {
                     // (e.g. `@param list<User> $users` vs native `array $users`).
                     // We apply `resolve_effective_type()` to pick the winner.
                     if name == "__construct" {
+                        constructor_body = Some(&method.body);
                         for param in method.parameter_list.parameters.iter() {
                             if param.is_promoted_property() {
                                 let raw_name = param.variable.name.to_string();
@@ -1970,6 +2001,22 @@ impl Backend {
                                     saved_native_hint.clone()
                                 };
 
+                                // When no type hint is available, infer from `new ClassName()`
+                                // default values (PHP 8.1+: `private $repo = new Repo()`).
+                                // Resolve to FQN eagerly so downstream code does not
+                                // need short-name resolution logic.
+                                let type_hint = type_hint.or_else(|| {
+                                    let dv = param.default_value.as_ref()?;
+                                    if let Expression::Instantiation(inst) = dv.value
+                                        && let Expression::Identifier(ident) = inst.class
+                                    {
+                                        let raw = ident.value().to_string();
+                                        let fqn = resolve_name_via_ctx(&raw, doc_ctx);
+                                        return Some(PhpType::Named(fqn));
+                                    }
+                                    None
+                                });
+
                                 let prop_name_offset = param.variable.span.start.offset;
                                 properties.push(PropertyInfo {
                                     name: prop_name,
@@ -2396,6 +2443,35 @@ impl Backend {
             }
         }
 
+        // Infer types for untyped properties from constructor assignments.
+        // Scans the constructor body for `$this->prop = new ClassName()`
+        // and fills in the type_hint when not set by declaration or docblock.
+        // Only applies when neither native type hint nor docblock type is present.
+        // Resolves to FQN eagerly so downstream code does not need
+        // short-name resolution logic.
+        if let Some(MethodBody::Concrete(concrete)) = constructor_body {
+            for stmt in concrete.statements.iter() {
+                if let Statement::Expression(expr_stmt) = stmt
+                    && let Expression::Assignment(assign) = expr_stmt.expression
+                    && let Expression::Access(Access::Property(pa)) = assign.lhs
+                    && let Expression::Variable(Variable::Direct(dv)) = pa.object
+                    && dv.name == "$this"
+                    && let ClassLikeMemberSelector::Identifier(ident) = &pa.property
+                    && let Expression::Instantiation(inst) = assign.rhs
+                    && let Expression::Identifier(class_ident) = inst.class
+                {
+                    let prop_name = ident.value.to_string();
+                    if let Some(prop) = properties.iter_mut().find(|p| {
+                        p.name == prop_name && p.type_hint.is_none() && p.native_type_hint.is_none()
+                    }) {
+                        let raw = class_ident.value().to_string();
+                        let fqn = resolve_name_via_ctx(&raw, doc_ctx);
+                        prop.type_hint = Some(PhpType::Named(fqn));
+                    }
+                }
+            }
+        }
+
         ExtractedMembers {
             methods,
             properties,