docs(release): correct unreleased Symfony feature notes

.github/workflows/ci.yml

@@ -104,6 +104,7 @@ jobs:
       - run: find examples/php -name '*.php' -print0 | xargs -0 -n1 php -l
       - run: php -d zend.assertions=1 examples/php/scaffolding/assertions.php
       - run: php -l examples/laravel/app/Demo.php
+      - run: find examples/symfony/src examples/symfony/config -name '*.php' -exec php -l {} \;
 
   benchmark:
     name: Benchmark

README.md

@@ -40,6 +40,7 @@ PHPantom focuses on deep type intelligence. Here's how it compares:
 | Closure parameter inference     | ✅       | 🚧           | 🚧         | 🚧          | 🚧          |
 | Laravel                         | ✅       | ❌           | 🚧         | ❌          | 🚧          |
 | Blade templates                 | 🚧       | ❌           | ✅         | ❌          | 🚧          |
+| Symfony / Twig / Doctrine       | ✅       | 🚧           | 🚧         | 🚧          | 🧩          |
 | Other frameworks<sup>4</sup>    | 🚧       | 🚧           | 🚧         | 🚧          | 🧩          |
 | **Refactoring**                 |          |              |            |             |             |
 | Rename                          | ✅       | 🔒           | 🔒         | ✅          | ✅          |
@@ -60,14 +61,14 @@ PHPantom focuses on deep type intelligence. Here's how it compares:
 <sup>1</sup> Completion, hover, signature help, go-to-definition, find references, diagnostics, document symbols.<br>
 <sup>2</sup> Auto-import, go-to implementation / type-definition, smart select, folding ranges, formatting, code lens, inlay hints, type hierarchy, document links.<br>
 <sup>3</sup> Implement interface methods, extract method/function, extract/inline variable, generate constructor, generate getter/setter.<br>
-<sup>4</sup> CakePHP, non-Composer WordPress, Symfony, Behat, PHPUnit, and Prophecy, and Twig.<br>
+<sup>4</sup> CakePHP, non-Composer WordPress, Behat, PHPUnit, and Prophecy.<br>
 <sup>5</sup> Convert between arrow functions and closures, and switch statements to match expressions.<br>
 Performance measured on a production codebase: 21K PHP files, 1.5M lines of code (vendor + application). Time to ready is CPU time consumed until full type intelligence is available on a cold start (first index); tools with a disk cache launch faster on subsequent starts.
 </sub>
 </p>
 
 > [!TIP]
-> **Want to verify?** Open [`examples/php/`](examples/php/) in your editor and trigger completion at the marked locations in `completion.php`. It exercises every type intelligence feature in the table, including edge cases where tools diverge. For Laravel specifically, open [`examples/laravel/`](examples/laravel/) — a standalone project with real Eloquent models, config, routes, views, and translations that exercises Eloquent property resolution, query builder chaining, scopes, custom collections, and go-to-definition for config keys, route names, and translation strings.
+> **Want to verify?** Open [`examples/php/`](examples/php/) in your editor and trigger completion at the marked locations in `completion.php`. It exercises every type intelligence feature in the table, including edge cases where tools diverge. Framework playgrounds live in [`examples/laravel/`](examples/laravel/) and [`examples/symfony/`](examples/symfony/).
 
 ## Context-Aware Intelligence
 
@@ -77,6 +78,7 @@ Performance measured on a production codebase: 21K PHP files, 1.5M lines of code
 - **Conditional return types.** PHPStan-style conditional `@return` types resolve to the concrete branch at each call site.
 - **Type aliases and shapes.** `@phpstan-type`, `@phpstan-import-type`, and `object{...}` shapes all resolve through to completions.
 - **Laravel.** Eloquent relationships, scopes, accessors, casts, and Builder chains resolve end-to-end. Macros behave like real methods. Container strings like `app('cache')` resolve to the bound class, `auth()->user()` resolves to your configured model, authorization strings resolve to the gate definition or policy method that declares them, and query string compleation on both relation and column names. Blade templates get completion, hover, go-to-definition, and diagnostics through virtual PHP preprocessing. No ide-helper or database access required.
+- **Symfony.** Container configuration, routes, Twig templates, translations, events, Messenger, forms, validation mappings, Doctrine metadata, and local configuration schemas participate in completion, navigation, references, rename, diagnostics, and code lenses across PHP, YAML, XML, XLIFF, and Twig.
 - **Everything else you'd expect.** Generics, type narrowing, named arguments, destructuring, first-class callables, anonymous classes, `@deprecated` detection, and namespace segment drilling.
 
 ## Project Awareness

config-schema.json

@@ -13,6 +13,31 @@
           "type": "string",
           "description": "Override the detected PHP version (e.g. \"8.3\"). When unset, PHPantom infers from composer.json's platform or require.php.",
           "pattern": "^\\d+\\.\\d+(\\.\\d+)?$"
+        },
+        "proxies": {
+          "type": "array",
+          "description": "Generated transparent-proxy discovery rules. Matching subclasses keep their PHP type, while project metadata is attributed to their real parent class.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "paths": {
+                "type": "array",
+                "description": "Workspace-relative PHP files, directories, or glob patterns to scan for generated proxy subclasses.",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "marker-interface": {
+                "type": "string",
+                "description": "Fully-qualified interface that a generated subclass must directly implement to be treated as a transparent proxy."
+              }
+            },
+            "required": [
+              "paths",
+              "marker-interface"
+            ]
+          },
+          "default": []
         }
       }
     },
@@ -147,6 +172,267 @@
         }
       }
     },
+    "symfony": {
+      "type": "object",
+      "description": "Symfony runtime metadata recovered statically from compiled containers and configured PHP attributes.",
+      "properties": {
+        "container": {
+          "type": "object",
+          "description": "Controls static compiled-container discovery. Container PHP is read as text and is never executed.",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Read Symfony compiled-container metadata.",
+              "default": true
+            },
+            "environment": {
+              "type": "string",
+              "description": "Cache environment used by automatic var/cache/<environment> discovery.",
+              "default": "dev"
+            },
+            "paths": {
+              "type": "array",
+              "description": "Optional workspace-relative compiled-container files, directories, or glob patterns. The newest useful match wins.",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "events": {
+          "type": "object",
+          "description": "Configures event-name matching and attribute adapters. Exact listener wiring comes from the compiled container.",
+          "properties": {
+            "ignored-prefixes": {
+              "type": "array",
+              "description": "Prefixes removed before event names are compared.",
+              "items": {
+                "type": "string"
+              }
+            },
+            "ignored-suffixes": {
+              "type": "array",
+              "description": "Suffixes removed before event names are compared.",
+              "items": {
+                "type": "string"
+              }
+            },
+            "publishers": {
+              "type": "array",
+              "description": "Rules that derive Symfony event publishers from PHP method attributes.",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "attribute": {
+                    "type": "string",
+                    "description": "Fully-qualified publisher attribute class."
+                  },
+                  "name-argument": {
+                    "type": "string",
+                    "description": "Named argument containing an explicit event name."
+                  },
+                  "name-position": {
+                    "type": "integer",
+                    "description": "Zero-based positional fallback for the explicit event-name argument.",
+                    "minimum": 0
+                  },
+                  "dispatch-argument": {
+                    "type": "string",
+                    "description": "Named argument containing dispatch enum cases."
+                  },
+                  "dispatch-position": {
+                    "type": "integer",
+                    "description": "Zero-based positional fallback for the dispatch argument.",
+                    "minimum": 0
+                  },
+                  "default-dispatch": {
+                    "type": "array",
+                    "description": "Dispatch names used when the attribute omits its dispatch argument.",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "dispatch-cases": {
+                    "type": "object",
+                    "description": "Map from PHP enum case name to the event-name dispatch segment.",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  },
+                  "name-template": {
+                    "type": "string",
+                    "description": "Derived event-name template. Supports {dispatch}, {class}, {class_snake}, {method}, {method_snake}, {method_suffix}, and {method_suffix_snake}."
+                  },
+                  "explicit-name-template": {
+                    "type": "string",
+                    "description": "Template used for explicit names. Supports the same placeholders plus {name}.",
+                    "default": "{name}"
+                  },
+                  "default-methods": {
+                    "type": "array",
+                    "description": "Method names that omit the method suffix.",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "skip": {
+                    "type": "array",
+                    "description": "Conditions that omit one derived dispatch when another attribute argument is set.",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "dispatch": {
+                          "type": "string"
+                        },
+                        "argument": {
+                          "type": "string"
+                        },
+                        "position": {
+                          "type": "integer",
+                          "minimum": 0
+                        }
+                      },
+                      "required": [
+                        "dispatch",
+                        "argument"
+                      ]
+                    }
+                  }
+                },
+                "required": [
+                  "attribute",
+                  "name-template"
+                ]
+              }
+            },
+            "subscribers": {
+              "type": "array",
+              "description": "Optional rules that expose event names written in subscriber method attributes before or without a compiled container.",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "attribute": {
+                    "type": "string",
+                    "description": "Fully-qualified subscriber attribute class."
+                  },
+                  "name-argument": {
+                    "type": "string"
+                  },
+                  "name-position": {
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "transport-argument": {
+                    "type": "string"
+                  },
+                  "transport-position": {
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "transport-cases": {
+                    "type": "object",
+                    "description": "Map from PHP enum case name to an event-name suffix.",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "required": [
+                  "attribute"
+                ]
+              }
+            }
+          }
+        },
+        "expression-language": {
+          "type": "object",
+          "description": "Maps configured PHP attribute and constructor arguments to Symfony ExpressionLanguage strings and their PHP type contracts.",
+          "properties": {
+            "attributes": {
+              "type": "array",
+              "description": "Method-attribute arguments that contain an expression string or an array of expression strings.",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "attribute": {
+                    "type": "string",
+                    "description": "Fully-qualified PHP method attribute class."
+                  },
+                  "argument": {
+                    "type": "string",
+                    "description": "Named argument containing expressions."
+                  },
+                  "position": {
+                    "type": "integer",
+                    "description": "Zero-based positional fallback for the expression argument.",
+                    "minimum": 0
+                  },
+                  "method-parameters": {
+                    "type": "boolean",
+                    "description": "Bind expression roots to method parameters with the same name.",
+                    "default": false
+                  },
+                  "bindings": {
+                    "type": "object",
+                    "description": "Map expression roots to return, parameter:<name-or-index>, or class:<FQN> type sources.",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "required": [
+                  "attribute"
+                ]
+              }
+            },
+            "constructors": {
+              "type": "array",
+              "description": "Expression object constructors nested inside PHP method attributes.",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "class": {
+                    "type": "string",
+                    "description": "Fully-qualified expression object class."
+                  },
+                  "argument": {
+                    "type": "string",
+                    "description": "Named constructor argument containing the expression."
+                  },
+                  "position": {
+                    "type": "integer",
+                    "description": "Zero-based positional fallback for the constructor argument.",
+                    "minimum": 0
+                  },
+                  "inside-attribute-prefixes": {
+                    "type": "array",
+                    "description": "Only match constructors nested in attributes whose FQN starts with one of these prefixes. An empty list matches any attribute.",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "method-parameters": {
+                    "type": "boolean",
+                    "description": "Bind expression roots to method parameters with the same name.",
+                    "default": false
+                  },
+                  "bindings": {
+                    "type": "object",
+                    "description": "Map expression roots to return, parameter:<name-or-index>, or class:<FQN> type sources.",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "required": [
+                  "class"
+                ]
+              }
+            }
+          }
+        }
+      }
+    },
     "formatting": {
       "type": "object",
       "description": "Controls the formatting strategy. PHPantom ships a built-in formatter (PER-CS 2.0 style). Projects with php-cs-fixer or PHP_CodeSniffer in composer.json require-dev automatically use those tools instead. Explicit configuration here always takes priority.",