# Php Inspections EA Extended: PHP Static Analysis for JetBrains IDEs > Php Inspections EA Extended is a Java-based PhpStorm and IntelliJ IDEA Ultimate plugin that adds static inspections for PHP architecture, types, performance, security, exceptions, compatibility, PHPUnit usage, and suspicious conditions. It is best suited to IDE-based PHP teams willing to accept the CPU and battery cost of deeper analysis. **kalessil/phpinspectionsea** — A Static Code Analyzer for PHP (a PhpStorm/Idea Plugin) - Repository: https://github.com/kalessil/phpinspectionsea - Website: https://plugins.jetbrains.com/plugin/7622?pr=phpStorm - Stars: 1,484 · Forks: 115 - Language: Java - License: NOASSERTION - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/kalessil-phpinspectionsea ## Why Php Inspections EA Extended Exists in the IDE Php Inspections EA Extended is a static code analyzer implemented as a plugin for PhpStorm 2024.3+ and IntelliJ IDEA Ultimate. Its intended users are PHP developers who want suspicious code patterns surfaced while working inside JetBrains IDEs, rather than through a separate analyzer service. The README describes coverage across architecture-related defects, weak type handling, possible construct simplifications, performance problems, duplicate or suspicious `if` conditions, magic method usage, regular expressions, exception handling, compatibility, PHPUnit APIs, security, and bugs that can consume substantial development time. This is a broad inspection catalog, not a general-purpose replacement for every category of PHP testing or analysis. The README does not document command-line execution, SARIF output, CI integration, rule configuration syntax, suppression files, or baseline support. It also does not claim compatibility with Community Edition IDEs. For that reason, the project fits best when an existing development workflow is already centered on a supported JetBrains product and findings can be reviewed in the editor. The distinction between PhpStorm and IDEA Ultimate matters. The README explicitly names PhpStorm 2024.3+ and IntelliJ IDEA Ultimate as supported hosts, but it does not say that earlier PhpStorm versions, other IntelliJ-based IDEs, or Community Edition editions work. A team should treat the documented host list as a product boundary rather than assuming generic IntelliJ plugin compatibility. ## Inspection Analysis Inside the JetBrains PHP Environment The repository is primarily Java and includes `src/`, `testData/`, Gradle build files, documentation, and rule-related files. That layout is consistent with a JetBrains plugin, while the project description identifies the resulting product as a PHP static analyzer. The README does not describe internal services, extension points, PSI traversal, indexing, daemon scheduling, or the format used to persist inspection state, so those implementation details cannot be confirmed. What can be established is the analyzer's operating context. It adds inspections to the IDE rather than presenting a documented batch pipeline. That design suggests findings belong to the normal source inspection experience, but the README does not spell out when each inspection runs or whether results appear in the Problems tool window. Readers should consult `docs/getting-started.md` and their IDE interface for those details. One documented behavior affects which code receives deeper scrutiny. Some inspections expect a conditional statement such as an `if` to wrap its body expressions in a group statement. When that requirement is met, the plugin applies additional inspections to that source code. This creates a trade-off: formatting that enables extra analysis can increase coverage, while the same choice may require source changes. The README does not say whether PhpStorm can rewrite these constructs automatically or whether nonconforming blocks are simply skipped. ## Installing the Plugin and Starting an Inspection The README states that PhpStorm must be version 2024.3 or newer, or that IntelliJ IDEA Ultimate must be used. It directs users to `docs/getting-started.md` for installation and initial setup. No install command, marketplace action sequence, IDE menu path, plugin archive, or configuration snippet is included in the repository documentation, so none is invented here. The supported starting point is therefore the project's own guide: Open the repository's `docs/getting-started.md` file and follow its installation steps for the supported JetBrains host. That instruction is not a substitute for the guide's exact UI steps. The clean README does not expose them. It also provides no sample PHP file and no documented way to trigger a named inspection, so there is no confirmed code example to present as a first run. A first practical use should begin after following the guide: open a PHP project in the supported IDE, let the plugin inspect the source, and review any findings that appear in the IDE's analysis interface. The final interface name is not documented in the README, so teams should not encode an assumed tool-window location into onboarding documentation. The repository contains `gradlew` and `gradlew.bat`, but the README does not use them for user installation. Those files belong to repository-level development and should not be presented as the documented consumer installation path without consulting the relevant build documentation. ## Rule Breadth Versus Runtime Cost The breadth of the inspection catalog is the main reason to evaluate the plugin, but it also makes noise and resource use practical adoption concerns. Categories such as performance, security, compatibility, magic methods, regular expressions, exceptions, PHPUnit, and architecture can overlap with different kinds of judgment. The README does not provide the number of inspections, examples of individual diagnostics, severity settings, quick fixes, disablement controls, or documentation for excluding paths. That leaves an important question unanswered: how much of the catalog should a typical project enable? The README gives a direct warning about computation. On some projects, CPU usage, and consequently battery usage, can be intensive. This makes the plugin a questionable choice on battery-constrained laptops or very large codebases unless developers measure its effect in the actual checkout. It is also a poor fit for a workflow that expects findings to be generated independently of an IDE. The conditional-group behavior adds another review consideration. Projects that already use explicit braces consistently may see more inspections become applicable. Projects with many unbraced conditional bodies may receive less coverage until they change formatting. The analyzer therefore does not have a completely uniform rule surface across codebases, even when two projects contain logically similar PHP code. ## Php Inspections EA Extended Versus Other PHP Analysis Approaches A real alternative is a standalone, batch-oriented PHP analyzer integrated into command-line and CI workflows. The README does not name such a tool or provide a feature comparison, so this review does not attach a vendor or benchmark claim to that category. The actual difference is architectural: this project is distributed as a JetBrains plugin for PhpStorm and IDEA Ultimate, while a batch analyzer would need a documented executable or service interface for CI. No such interface is documented for Php Inspections EA Extended. The plugin approach can suit developers who want findings close to source editing and already use a supported JetBrains IDE. A standalone analyzer is the more natural fit when findings must be produced on a build server, enforced across pull requests, exported into machine-readable reports, or applied in environments without a desktop IDE. Those requirements are not explicitly supported or rejected here because the project documentation is silent on them. The README also points readers toward Php Inspections EA Ultimate after they have accommodated themselves with the analyzer. It describes that product as a way to move further and says funding from Ultimate license purchases supports maintenance and new features. This establishes a commercial companion, but the README does not enumerate feature differences, pricing, compatibility, or licensing terms for it. ## Licensing, Maintenance, and Upgrade Work GitHub classifies the repository license as a custom license that it cannot categorize, so the relevant source for permitted use is `LICENSE.md`. This review does not infer an open source license category from the README's “OSS” wording. Engineers should read `LICENSE.md` for actual permissions and restrictions, especially because the analyzer is distributed through the JetBrains plugin marketplace and the project also points to a commercial companion product. The repository is not archived. Its last push was on 2026-08-28, which is recent relative to the project review, although there are no GitHub releases to use as a version history. That does not mean every IDE update is documented as a repository release. The README requires PhpStorm 2024.3+, but it does not explain the plugin's supported version range, migration process, compatibility matrix, or behavior when a new IDE release changes inspection APIs. There is a visible CI workflow reference in the README, and the repository includes `build.gradle.kts`, `settings.gradle`, wrapper scripts, release scripts, and test data. Those entries show a development and release-oriented repository layout. The README does not explain contributor setup, release signing, compatibility testing, or the effort required to upgrade the plugin, so those maintenance costs remain unquantified. ## Adoption Boundaries for Php Inspections EA Extended The documented value is clear: developers using PhpStorm 2024.3+ or IntelliJ IDEA Ultimate can add editor-local checks for several classes of PHP problems that are easy to miss during routine editing. The plugin has particular relevance to codebases that want attention paid to architecture constraints, weak types, duplicated conditions, magic methods, exception workflows, PHPUnit API calls, security patterns, and compatibility. Its boundaries are equally concrete. The project does not document a CLI or CI workflow, and the README explicitly warns that CPU and battery use can be intensive on some projects. It is therefore unsuitable as the sole analysis mechanism for teams requiring a known server-side reporting contract. Its conditional-group requirement also means source formatting affects which additional inspections run. Before adoption, the first checks should be concrete: confirm the IDE edition and version, read `LICENSE.md`, review `RULES.md` for project-relevant policies, and consult `docs/getting-started.md` for the actual installation sequence. If those checks pass and the analysis cost is acceptable on a representative checkout, the plugin's editor-integrated PHP inspections make it a credible choice for a JetBrains-based PHP team. ## Conclusion PhpStorm developers and IDEA Ultimate users should consider this plugin when they want editor-local PHP inspections beyond those supplied by the IDE, especially for architecture rules, PHPUnit usage, exception workflows, and suspicious conditions. It is a poor fit for PHP work outside the supported JetBrains environment, for teams that cannot accept potentially intensive CPU and battery use, or for developers who need a documented command-line analyzer. Before adoption, verify the custom terms in `LICENSE.md`, inspect the relevant inspections in `RULES.md`, and confirm that PhpStorm 2024.3 or a compatible IDEA Ultimate edition is part of the target environment. ## FAQ ### Which IDEs and versions support Php Inspections EA Extended? The README states that the plugin targets PhpStorm 2024.3+ and IntelliJ IDEA Ultimate. It does not document support for older PhpStorm releases, IntelliJ IDEA Community Edition, or other JetBrains IDEs. ### Can Php Inspections EA Extended run from the command line or in CI? The README does not document a command-line interface, report export, or CI integration. The repository contains Gradle wrapper files, but they are not presented as a consumer installation or analysis interface. ### What license applies to Php Inspections EA Extended? GitHub cannot classify the license as a standard open source license. The repository points to `LICENSE.md`, which is the source to consult for its actual permissions and restrictions. ### Why might some conditional expressions receive more inspections? Some inspections expect statements such as an `if` to wrap their body expressions in a group statement. When that requirement is met, the README says additional inspections are applied to the source code. ### Does running Php Inspections EA Extended affect laptop performance? The README warns that CPU usage, and therefore battery usage, can be intensive on some projects. The actual impact must be checked against a representative PHP codebase and developer hardware because no performance measurements are provided. ## Sources - [Issues](https://github.com/kalessil/phpinspectionsea/issues) - [kalessil/phpinspectionsea on GitHub](https://github.com/kalessil/phpinspectionsea) - [Project website](https://plugins.jetbrains.com/plugin/7622?pr=phpStorm) - [README](https://github.com/kalessil/phpinspectionsea/blob/master/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kalessil-phpinspectionsea