Skip to content
CAI
Software that uses CAICheck a score

vimeo/psalm

65.6

Adequate · 17 November 2026

2659.8k

lines of production code

PHP

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add PHAR distribution assets for standalone Psalm installation

New files have been added to the assets/psalm-phar directory to support a standalone PHAR distribution of Psalm. This includes a README explaining that the PHAR allows installation without composer dependency conflicts, and a .gitignore file configured to exclude composer artifacts like composer.phar, the vendor directory, and lock files, ensuring the PHAR package remains self-contained.

assets · high confidence

Add composer-based echo-checker plugin example

The examples/plugins/composer-based directory now includes a new echo-checker plugin that demonstrates how to implement the AfterStatementAnalysisInterface. This example plugin registers a hook to detect when PHP's echo statement is used with mixed or non-literal string types, reporting an ArgumentTypeCoercion issue to help users identify potential security or type-safety concerns in their code.

examples/plugins/composer-based · high confidence

Add template analysis example tools

Introduces two new example classes, TemplateAnalyzer and TemplateScanner, in the examples directory. These tools enable static analysis of view templates by parsing a specific docblock tag (variablesfrom) to infer context from a source class, allowing the analyzer to check template files against the variables and types available in their associated view classes.

examples · high confidence

Add type provider for DOMDocument properties

Psalm now recognizes the \documentElement\ property on \DOMDocument\ as returning \DOMElement\|null\, improving type accuracy for DOM manipulation code.

src/Psalm/Internal/Provider/PropertyTypeProvider · high confidence

Comprehensive PHP stubs for core classes, functions, and version-specific features

This release introduces a complete set of PHP stubs that significantly improve type inference and static analysis accuracy. The stubs cover core generic classes (ArrayAccess, ArrayObject, Generator, Traversable), iterators (Iterator, IteratorAggregate, SplDoublyLinkedList, SplFixedArray), and functions (array\\, string\\, etc.) with precise return types, template parameters, and purity annotations. It also adds version-gated refinements for PHP 8.0 (ReflectionClass, get\_headers, pack), PHP 8.1 (ReflectionClass::isEnum, setAccessible purity, enums), PHP 8.2 (ReflectionUnionType, DatePeriod::INCLUDE\_END\_DATE, str\_split), and PHP 8.4 (lazy object reflection methods). Additionally, it defines new classes like Stringable, CurlHandle, and enum-related reflection classes, and introduces stubs for PHP 8.2 attributes (AllowDynamicProperties, Override, SensitiveParameter, Deprecated) and PhpParser nodes.

stubs · high confidence

Improved return type inference for array manipulation functions

Psalm now provides precise return types for several array functions, including array\_chunk, array\_column, array\_combine, array\_fill\_keys, array\_fill, array\_filter, array\_map, array\_merge, array\_pad, array\_pop, array\_rand, and pointer adjustments (current, next, prev, reset, end). These new providers analyze input array structures and arguments to infer specific list types, keyed arrays, and non-empty states, reducing false positives and improving type safety when working with array transformations.

src/Psalm/Internal/Provider/ReturnTypeProvider · high confidence

In-memory project cache provider for language server

Added InMemoryProjectCacheProvider, an in-memory implementation of the project cache provider used by the language server. This provider tracks the last successful run time to determine whether file diffs can be processed, enabling more efficient incremental analysis within the language server context without relying on persistent storage.

src/Psalm/Internal/LanguageServer/Provider · high confidence

Initial repository scaffolding and configuration

This change establishes the foundational project structure for Psalm, introducing essential configuration and metadata files. It adds the MIT \LICENSE\, a \CODE\_OF\_CONDUCT.md\, and a \CONTRIBUTING.md\ guide. The repository is configured with \.editorconfig\ for consistent coding styles, \.gitignore\ and \.gitattributes\ for version control hygiene, and a \config.xsd\ schema to validate \psalm.xml\ configurations. Build and test infrastructure is set up via \box.json.dist\ for PHAR generation, \phpunit.xml.dist\ for test execution, and \phpcs.xml\ for code style enforcement. Additionally, executable entry points (\psalm\, \psalm-language-server\, \psalm-plugin\, \psalm-refactor\, \psalm-review\) are created to launch the tool, alongside a \psalm.xml.dist\ default configuration and a \psalm-baseline.xml\ to track known issues.

(repo-wide) · high confidence

Introduce CustomTraverser for AST node traversal

A new CustomTraverser class has been added to the internal PHP traverser component, extending PhpParser's NodeTraverser to provide a custom implementation for recursively traversing and modifying Abstract Syntax Tree (AST) nodes. This change introduces specific logic for handling node visitors, allowing for the replacement, removal, or stopping of traversal during the analysis process, which serves as the underlying mechanism for how Psalm inspects and transforms PHP code structures.

src/Psalm/Internal/PhpTraverser · high confidence

Introduce SourceControlInfo data structures for Git repository metadata

Added new classes in the \src/Psalm/SourceControl\ namespace (\SourceControlInfo\, \GitInfo\, \CommitInfo\, \RemoteInfo\) to model Git repository information, including branch, remote URLs, and commit details (ID, author, committer, message, and date). These classes provide a structured \toArray()\ representation of the current Git state, likely to support integration with coverage reporting tools like Coveralls or similar services that require source control metadata.

src/Psalm/SourceControl · high confidence

Introduce custom PHP Docker image with JIT and security hardening

The project now ships a custom Dockerfile in bin/docker that compiles PHP 8.4 from source on Debian Bookworm, applying a deepbind patch to improve library loading security and enabling jemalloc for better memory performance. The image includes a hardened php.ini with aggressive OPcache JIT settings, the igbinary extension, and SSH support, alongside standard docker-php-ext helper scripts to manage extensions. An entrypoint script is also provided to run Psalm with taint analysis and JIT enabled, allowing users to build and run the project's static analysis in a consistent, optimized container environment.

bin/docker · high confidence

Introduce new internal classes and interfaces for plugin and report handling

The codebase adds several new internal components to support plugin extensibility and output formatting. A new \Aliases\ class is introduced to store namespace and use-statement data, and a \FileSource\ interface is defined to standardize file path and alias access. Plugin loading is expanded with \FileBasedPluginAdapter\ for loading plugins from file paths, \PluginFileExtensionsSocket\ to allow plugins to register custom file-type scanners and analyzers, and \PluginRegistrationSocket\ to handle the registration of various plugin event handlers. Additionally, a \FileManipulation\ class is added to manage code transformations, and the \Report\ class is updated to include new output format constants (such as SARIF, CodeClimate, and GitHub Actions) and a file-extension mapping.

src/Psalm · high confidence

Introduce virtual node classes to differentiate real nodes in plugins

Psalm now includes a comprehensive set of virtual node classes (e.g., \VirtualBitwiseAnd\, \VirtualArray\, \VirtualClass\) that extend PhpParser node types and implement the \VirtualNode\ interface. This change allows plugins and internal logic to distinguish between nodes that were parsed from actual source code and those that were generated synthetically, enabling more accurate analysis and handling of programmatically created AST elements.

src/Psalm/Node · high confidence

New CLI commands to manage plugins

Psalm now includes three new console commands—\psalm enable\, \psalm disable\, and \psalm show\—allowing users to enable or disable specific plugins by name and view the current list of enabled and available plugins. These commands support a \--config\ option to specify a custom configuration file path and provide clear feedback on whether a plugin was successfully modified or was already in the desired state.

src/Psalm/Internal/PluginManager/Command · high confidence

New FormulaGenerator for handling assertion logic

A new FormulaGenerator class has been introduced in the Internal Algebra component to centralize the generation of logical clauses from conditional expressions. This change implements specific logic for handling Boolean AND/OR operations and applies De Morgan's laws to simplify assertion negations (e.g., converting negated ORs into ANDs of negations), which helps streamline how Psalm processes and optimizes complex type assertions during static analysis. Also in this area: 5 commits (1 fix) modifying src/Psalm/Internal/Algebra; 13 commits (2 fixes) modifying src/Psalm/Internal/Algebra.

src/Psalm/Internal/Algebra · medium confidence · unverified

New Hack conformance harness to verify Psalm's type-variable and context behavior

A new CLI harness under \bin/hack-conformance\ ensures Psalm's handling of class-template type variables and Hack contexts (capabilities, purity templates) matches the HHVM typechecker. It uses hand-written Hack fixtures in \fixtures/\ as the source of truth, runs them against a pinned HHVM Docker image via \run.php\, and transpiles the HHVM parse trees into PHP with Psalm docblocks via \transpile.php\ to generate a PHPUnit test suite (\tests/HackConformanceTranspiledTest.php\). This suite asserts that Psalm produces the same verdicts as HHVM, with a \track-upstream.php\ script to monitor upstream Hack test changes.

bin/hack-conformance · high confidence

New example plugins for code quality and security enforcement

The examples/plugins directory now includes several new plugin implementations demonstrating advanced Psalm capabilities. ClassUnqualifier automatically refactors fully qualified class names to use imported aliases. FunctionCasingChecker detects and reports incorrect casing in function and method calls. InternalChecker identifies Psalm internal classes that lack the @internal annotation and can auto-fix them. PreventFloatAssignmentChecker flags assignments to float values. SafeArrayKeyChecker removes HTML taints from array items with the key 'safe\_key'. StringChecker enforces the use of ::class constants and detects undefined methods in concatenated strings. TaintActiveRecords automatically marks property fetches from the app\\models namespace as tainted to improve security analysis.

examples/plugins · high confidence

New internal classes for collecting CI and Git environment information

Added three new internal classes in src/Psalm/Internal/ExecutionEnvironment: BuildInfoCollector, GitInfoCollector, and SystemCommandExecutor. BuildInfoCollector gathers CI-specific environment variables (Travis CI, CircleCI, AppVeyor, Jenkins, Scrutinizer, GitHub Actions) and normalizes them into a standard format. GitInfoCollector executes git commands to collect branch, commit, and remote information. SystemCommandExecutor provides a wrapper for executing system commands, including a check for the existence of the exec function to handle environments where it is disabled.

src/Psalm/Internal/ExecutionEnvironment · high confidence

New plugin event handler interfaces for analysis hooks and taint control

The plugin system now exposes a comprehensive set of new interfaces in the EventHandler namespace, allowing plugins to hook into specific stages of the static analysis process. These include lifecycle hooks such as BeforeExpressionAnalysis, BeforeStatementAnalysis, BeforeFileAnalysis, and various AfterAnalysis interfaces (e.g., AfterClassLikeAnalysis, AfterFunctionCallAnalysis) that let plugins inspect or modify analysis behavior at precise points. Additionally, new interfaces for taint management (AddTaintsInterface, RemoveTaintsInterface) enable plugins to programmatically add or remove taints during analysis. Provider interfaces for function/method/property existence, parameters, return types, and visibility allow plugins to supply custom type information and existence checks for symbols not natively known to Psalm. A BeforeAddIssueInterface also permits plugins to intercept and suppress or modify issues before they are reported.

src/Psalm/Plugin/EventHandler · high confidence

New psalm-review tool with auto-detected IDE support

Psalm now includes a new \psalm-review\ CLI command that iterates through issues from a JSON baseline file, displaying them one by one with code snippets and offering to open the relevant file in your IDE. The tool automatically detects the current IDE (PhpStorm, VS Code, or code-server) via environment variables when run inside an integrated terminal, or accepts an explicit IDE argument (e.g., \code\, \phpstorm\) to determine how to launch the editor. It also supports filtering issues by type and reversing the list.

src/Psalm/Internal/Cli · high confidence

Architecture

Extracted LSP method handlers into dedicated Server classes

The Language Server Protocol method handlers for text documents and workspace operations have been extracted from the main server into new, dedicated classes: \Server/TextDocument.php\ and \Server/Workspace.php\. This refactoring organizes the implementation of core LSP notifications and requests—such as \didOpen\, \didSave\, \didChange\, \didClose\, \definition\, \didChangeWatchedFiles\, and \executeCommand\—into focused components, improving code structure and maintainability without changing external behavior.

src/Psalm/Internal/LanguageServer/Server · high confidence

Introduce dedicated storage classes for analysis metadata

Psalm now uses a set of new, immutable storage classes in the \src/Psalm/Storage\ directory to hold analysis data for classes, methods, properties, constants, and assertions. This refactors the internal representation of type information, attributes, and template constraints into dedicated objects (such as \ClassLikeStorage\, \MethodStorage\, \PropertyStorage\, \Assertion\, and \Possibilities\), replacing previous flat or string-based structures to improve type safety and memory management during static analysis.

src/Psalm/Storage · high confidence

Refactor PHP visitor logic into specialized, internal AST node visitors

The internal PHP visitor logic in src/Psalm/Internal/PhpVisitor has been broken up into a suite of specialized, final classes (such as AssignmentMapVisitor, CheckTrivialExprVisitor, CloningVisitor, and ReflectorVisitor) that extend PhpParser's NodeVisitorAbstract. This refactoring replaces previous monolithic or ad-hoc analysis approaches with distinct, focused visitors for specific tasks like tracking assignment maps, cloning nodes for format-preserving pretty printing, resolving names, and collecting yield types, improving the modularity and maintainability of the static analysis engine.

src/Psalm/Internal/PhpVisitor · high confidence

Refactor analyzer internals and introduce new analysis components

The analyzer package has been restructured by moving internal classes into the \Psalm\\Internal\\Analyzer\ namespace and introducing new dedicated analyzers. A new \AlgebraAnalyzer\ has been added to handle logical condition checks, such as detecting paradoxical or redundant conditions. The \CanAlias\ trait has been extracted to manage use-statement aliasing, and a new \DataFlowNodeData\ class has been introduced to support data flow analysis. Additionally, the \ClassLikeNameOptions\ class has been added to encapsulate options for class-like name resolution.

src/Psalm/Internal/Analyzer · high confidence

Refactor atomic type system into immutable classes and traits

Psalm's internal type representation has been restructured to use immutable classes and traits, replacing the previous string-based or mutable implementations. This change introduces dedicated classes for core types (such as TArray, TCallable, TClassString, and TClosure) and shared logic via traits (CallableTrait, GenericTrait, HasIntersectionTrait), ensuring that type objects cannot be modified after creation. For users, this provides more robust and predictable static analysis, particularly for complex generic and callable types, as the engine now relies on value-based equality and immutable state transitions rather than mutable object properties.

src/Psalm/Type/Atomic · high confidence

Refactor expression analysis into dedicated analyzer classes

The static analysis logic for PHP expressions has been restructured from monolithic classes into specialized, single-responsibility components. New classes such as ArrayAnalyzer, BitwiseNotAnalyzer, BooleanNotAnalyzer, and AssertionFinder now handle specific expression types (arrays, bitwise/boolean negations, and conditional assertions respectively), while existing logic in AssignmentAnalyzer, BinaryOpAnalyzer, and CallAnalyzer has been refactored to delegate to these new handlers. This change improves code maintainability and allows for more granular type inference and taint tracking for individual expression operations.

src/Psalm/Internal/Analyzer/Statements/Expression · high confidence

Refactor internal codebase analysis into dedicated domain classes

The internal codebase analysis logic has been reorganized into a set of focused classes within \src/Psalm/Internal/Codebase\. This change introduces \Analyzer\ to handle the main analysis orchestration, \ClassLikes\ for class/interface/trait/enum management, \Methods\ for method resolution, \Properties\ for property handling, and \Functions\ for function storage. It also adds specialized resolvers like \AssertionsFromInheritanceResolver\ and \ClassConstantByWildcardResolver\, and extracts the data flow graph logic into \DataFlowGraph\. This restructuring improves the separation of concerns within the static analysis engine. Also in this area: 10 commits (1 fix) modifying src/Psalm/Internal/Codebase; 8 commits (2 fixes) modifying src/Psalm/Internal/Codebase; Improved type inference for string casts and array keys; Improved type inference for ArrayAccess destructuring and precise taint reporting for stubbed parameters.

src/Psalm/Internal/Codebase · medium confidence · unverified

Refactor plugin management into dedicated internal classes

The plugin management logic in src/Psalm/Internal/PluginManager has been restructured into four new internal classes: ComposerLock, ConfigFile, PluginList, and PluginListFactory. ComposerLock now handles reading and parsing composer.lock files to identify available plugins. ConfigFile manages the reading and writing of plugin entries in the Psalm XML configuration. PluginList coordinates between the config and lock files to resolve, enable, and disable plugins. PluginListFactory orchestrates the creation of these components, including logic to locate composer.lock files in various project structures. This change improves code organization and separation of concerns within the plugin manager.

src/Psalm/Internal/PluginManager · high confidence

Refactor type system to use immutable Union types and new visitor interfaces

The type system in src/Psalm/Type has been refactored to enforce immutability on Union types, introducing a new ImmutableUnion class and a MutableUnion variant for internal construction, alongside new TypeNode, TypeVisitor, and MutableTypeVisitor interfaces to standardize type traversal. This change ensures that type objects cannot be modified after creation, improving reliability in analysis, while the Reconciler and Atomic classes have been updated to work with this new immutable structure.

src/Psalm/Type · high confidence

Refactor type visitors into dedicated classes

The type visitor logic in Psalm has been refactored from monolithic implementations into a suite of dedicated, single-responsibility classes within the \src/Psalm/Internal/TypeVisitor\ directory. This change introduces new classes such as \CanContainObjectTypeVisitor\, \CapturedValueVisitor\, \ClasslikeReplacer\, \ConditionalSubjectReplacer\, \ContainsClassLikeVisitor\, \ContainsLiteralVisitor\, \ContainsStaticVisitor\, \DeferredIntersectionCollector\, \FromDocblockSetter\, \FunctionPurityTemplateReplacer\, \PurityWildcardBinder\, \PurityWildcardFinder\, \TemplateTypeCollector\, \TypeChecker\, \TypeLocalizer\, \TypeScanner\, and \TypeVariableResolver\. This modularization improves code maintainability and allows for more precise type analysis operations, such as handling purity wildcards, resolving type variables, and managing class-like replacements.

src/Psalm/Internal/TypeVisitor · high confidence

Refactored binary operator analysis into dedicated analyzer classes

The binary operator analysis logic has been restructured into specific, dedicated classes (AndAnalyzer, OrAnalyzer, CoalesceAnalyzer, ConcatAnalyzer, ArithmeticOpAnalyzer, and NonComparisonOpAnalyzer) within the BinaryOp directory. This change improves the maintainability and accuracy of type inference and data flow analysis for operators like concatenation, arithmetic, and logical operations by isolating their complex reconciliation and clause-handling logic. Also in this area: 10 commits (1 fix) modifying src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp; 21 commits (7 fixes) modifying src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp.

src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp · medium confidence · unverified

Refactored configuration file filtering and issue handling into dedicated classes

The configuration logic in src/Psalm/Config has been restructured to improve modularity and maintainability. File filtering logic is now encapsulated in a hierarchy of classes: a base FileFilter, specialized filters like ProjectFileFilter and TaintAnalysisFileFilter, and a new ErrorLevelFileFilter for granular error level overrides. Additionally, a new IssueHandler class centralizes the logic for determining reporting levels for various issue types (files, classes, methods, properties, etc.) based on these filters. A new Creator class handles the generation of bare Psalm configuration files. This change affects how Psalm parses and applies configuration rules for file inclusion/exclusion and error severity.

src/Psalm/Config · high confidence

Refactored expression fetch analysis into dedicated analyzer classes

The monolithic statement analysis logic for fetching values has been split into five specialized classes within the \src/Psalm/Internal/Analyzer/Statements/Expression/Fetch\ directory: \ArrayFetchAnalyzer\ for array access, \AtomicPropertyFetchAnalyzer\ for property reads, \ConstFetchAnalyzer\ for constant resolution, \InstancePropertyFetchAnalyzer\ for instance property access, and \StaticPropertyFetchAnalyzer\ for static property access. This refactoring isolates the specific type-checking, taint-tracking, and error-reporting logic for each fetch type, improving code maintainability and allowing more granular analysis of variable, constant, and property accesses.

src/Psalm/Internal/Analyzer/Statements/Expression/Fetch · high confidence

Refactored function and method call analysis into specialized classes

The logic for analyzing function and method calls has been extracted from monolithic analyzers into a set of dedicated classes within the \src/Psalm/Internal/Analyzer/Statements/Expression/Call\ directory. This includes new components such as \ArgumentAnalyzer\, \ArgumentsAnalyzer\, \ArrayFunctionArgumentsAnalyzer\, \FunctionCallAnalyzer\, \FunctionCallReturnTypeFetcher\, and \HighOrderFunctionArgHandler\. This change improves the maintainability and granularity of the static analysis engine by separating concerns for argument validation, return type resolution, and higher-order function handling.

src/Psalm/Internal/Analyzer/Statements/Expression/Call · high confidence

Refactored if/else analysis into dedicated analyzer classes

The logic for analyzing if, elseif, and else blocks has been extracted from the monolithic IfElseAnalyzer into three new, dedicated classes: IfAnalyzer, ElseIfAnalyzer, and ElseAnalyzer. This structural change improves code organization and maintainability by separating the concerns of each conditional branch type, while preserving the existing type-reconciliation and context-update behavior for users. Also in this area: 28 commits (1 fix) modifying src/Psalm; 9 commits (0 fixes) modifying src/Psalm/Internal/Analyzer/Statements/Block/IfElse.

src/Psalm/Internal/Analyzer/Statements/Block/IfElse · medium confidence · unverified

Refactored internal type providers and storage caching into dedicated classes

The internal analysis engine has been restructured to improve modularity and performance. Type inference for functions and methods is now handled by dedicated provider classes (FunctionReturnTypeProvider, MethodReturnTypeProvider, FunctionParamsProvider, MethodParamsProvider) that register specific handlers for built-in functions (e.g., array operations, date/time, string manipulation) and custom plugins. Additionally, storage for class and file analysis results is now managed by separate providers (ClassLikeStorageProvider, FileStorageProvider) with their own caching layers (ClassLikeStorageCacheProvider, FileStorageCacheProvider), enabling more granular cache invalidation and faster subsequent runs.

src/Psalm/Internal/Provider · high confidence

Refactored return type analysis into dedicated analyzer and collector classes

The logic for analyzing function return types has been extracted from the main FunctionLike analyzer into two new internal classes: ReturnTypeAnalyzer and ReturnTypeCollector. ReturnTypeAnalyzer now handles the verification of return types against declarations and docblocks, while ReturnTypeCollector is responsible for traversing function statements to infer return types, including handling yields, control flow, and implicit returns. This structural change improves the modularity of the static analysis engine without altering the external behavior of return type checking.

src/Psalm/Internal/Analyzer/FunctionLike · high confidence

Refactored statement analysis into dedicated analyzer classes

The statement analysis logic in \src/Psalm/Internal/Analyzer/Statements\ has been broken out from the monolithic \StatementsAnalyzer\ into dedicated, single-responsibility classes (e.g., \BreakAnalyzer\, \ContinueAnalyzer\, \ReturnAnalyzer\, \UnsetAnalyzer\). This refactoring improves code maintainability and allows for more granular control over specific PHP constructs, such as precise taint tracking for \echo\ statements and refined type inference for \break\ and \continue\ within switch contexts.

src/Psalm/Internal/Analyzer/Statements · high confidence

Refactored type comparison logic into specialized comparator classes

Psalm's internal type comparison engine has been restructured by extracting specific comparison logic into dedicated classes within the \src/Psalm/Internal/Type/Comparator\ directory. New files such as \ArrayTypeComparator\, \AtomicTypeComparator\, \CallableTypeComparator\, \ClassLikeStringComparator\, \GenericTypeComparator\, \IntegerRangeComparator\, \KeyedArrayComparator\, and \ObjectComparator\ now handle the \isContainedBy\ checks for their respective type domains. This change centralizes the logic for comparing arrays, callables, generics, integer ranges, keyed arrays, and objects, improving the modularity and maintainability of the type system's core comparison mechanisms.

src/Psalm/Internal/Type/Comparator · high confidence

Refactored type reconciliation and parsing into dedicated internal classes

The type reconciliation logic in \src/Psalm/Internal/Type\ has been restructured into specialized components: \AssertionReconciler\ and \NegatedAssertionReconciler\ now handle positive and negative type assertions respectively, delegating to \SimpleAssertionReconciler\ and \SimpleNegatedAssertionReconciler\ for atomic refinements. A new \ClosedInheritanceToUnion\ utility expands sealed class hierarchies into unions during reconciliation, while \ArrayType\ provides a unified representation for array types. Additionally, the type parsing system has been migrated to an internal \ParseTree\ structure with a dedicated \ParseTreeCreator\, replacing the previous parsing approach to improve maintainability and error handling.

src/Psalm/Internal/Type · high confidence

Behavioural changes

1 commit (0 fixes) modifying bin

A change to existing behaviour in bin — 1 commit, 1 file: “Re-enable skipped tests that pass, link the others to their issues”. Also in this area: New Hack conformance harness to verify Psalm's type-variable and context behavior.

(repo-wide) · low confidence · unverified

11 commits (1 fix) modifying bin/perf

A change to existing behaviour in bin/perf — 11 commits (1 fix), 9 files: “Merge remote-tracking branch 'origin/master' into fix/6891-conditional-on-never”; “ci(perf): add Monolog to the perf corpus \#13034”; “Add guzzle/promises to the perf corpus”; and 7 more (refs \#13034, \#0).

bin/perf · medium confidence · unverified

211 commits (83 fixes) modifying src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod

A change to existing behaviour in src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod — 211 commits (83 fixs), 2 files: “fix(static-calls): self::, static:: and parent:: return the static type of the calling class \#7797”; “Pass a context wherever possible”; “Resolve self/parent/static of static property assertions at the call”; and 206 more (refs \#7797, \#7411, \#7410, \#6165, \#8330, …).

src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod · medium confidence · unverified

330 commits (90 fixes) modifying src/Psalm/Internal/Analyzer/Statements/Expression/Assignment

A change to existing behaviour in src/Psalm/Internal/Analyzer/Statements/Expression/Assignment — 330 commits (90 fixs), 4 files: “Don’t manipulate property storage during analysis”; “Immutable readonly 3”; “Fix \#4467 - variables are only the same if they were set in the same location”; and 317 more (refs \#4467, \#2223, \#5196, \#3084, \#13448, …).

src/Psalm/Internal/Analyzer/Statements/Expression/Assignment · medium confidence · unverified

430 commits (119 fixes) modifying src/Psalm/Internal

A change to existing behaviour in src/Psalm/Internal — 430 commits (119 fixs), 20 files: “Throw and catch exception when specified PHP version is invalid”; “Completely remove TCallableKeyedArray”; “Use all composer autoloaders when resolving paths”; and 364 more (refs \#13779, \#13307, \#4275, \#7410, \#7956, …).

src/Psalm/Internal · medium confidence · unverified

483 commits (168 fixes) modifying src/Psalm/Internal/PhpVisitor/Reflector

A change to existing behaviour in src/Psalm/Internal/PhpVisitor/Reflector — 483 commits (168 fixs), 14 files: “Fix \#5383 - prevent unsound use of new static for generics”; “Immutable readonly 3”; “Deprecate FunctionLikeStorage::$unused\_docblock\_params”; and 465 more (refs \#5383, \#8266, \#5407, \#7410, \#7731, …).

src/Psalm/Internal/PhpVisitor/Reflector · medium confidence · unverified

5 commits (2 fixes) modifying stubs/libraries/psr

A change to existing behaviour in stubs/libraries/psr — 5 commits (2 fixs), 6 files: “fix(stubs): don't restrict psr/log and Monolog logging methods \#13034”; “Declare the capabilities of psr/log's LoggerTrait, AbstractLogger and NullLogger in its stub”; “Declare the capabilities of Monolog and of psr/log's LoggerInterface in their library stubs”; and 2 more (refs \#13034).

(repo-wide) · medium confidence · unverified

53 commits (6 fixes) modifying dictionaries/autogen

A change to existing behaviour in dictionaries/autogen — 53 commits (6 fixs), 24 files: “feat(callmap): Add PHP 8.5 support”; “Update the files composer build generates”; “Apply composer build patch”; and 26 more (refs \#11256, \#12937).

dictionaries/autogen · medium confidence · unverified

62 commits (12 fixes) modifying bin/stubs

A change to existing behaviour in bin/stubs — 62 commits (12 fixs), 11 files: “Let install-php-extensions treat PHP 8.6 like the versions it supports”; “feat(callmap): Add PHP 8.5 support”; “Check the PIE package versions”; and 51 more (refs \#12937, \#11558, \#13756).

bin/stubs · medium confidence · unverified

7 commits (1 fix) modifying src/Psalm/Node/Expr

A change to existing behaviour in src/Psalm/Node/Expr — 7 commits (1 fix), 91 files: “Fix code style: blank line between docblock description and @api”; “Introduce Virtual Nodes in order to differentiate real nodes in plugins (\#5222)”; “Mark all non-internal classes and interfaces as @api”; and 4 more (refs \#5222, \#12914, \#11865).

src/Psalm/Node/Expr, src/Psalm/Node/Stmt · medium confidence · unverified

84 commits (28 fixes) modifying dictionaries/override

A change to existing behaviour in dictionaries/override — 84 commits (28 fixs), 12 files: “Cleanup”; “Add array function parameter type providers (\#11247)”; “Treat New Relic agent functions as impure and correct their signatures”; and 56 more (refs \#11247, \#4991, \#8081, \#6411, \#11645, …).

dictionaries/override · medium confidence · unverified

Assertion types are now immutable value objects

Psalm's internal assertion system has been refactored from string-based representations to a set of immutable, final PHP classes in the \Psalm\\Storage\\Assertion\ namespace (e.g., \IsType\, \HasMethod\, \IsIdentical\). This change ensures that assertions are treated as distinct, immutable value objects with explicit negation logic, improving type safety and clarity in how Psalm stores and reconciles type information.

src/Psalm/Storage/Assertion · high confidence

Complete rewrite of report output classes to use IssueData objects and new formatters

The report generation logic in src/Psalm/Report has been completely rewritten to consume IssueData objects instead of raw arrays, introducing a suite of new and updated report formatters. This change adds support for multiple output formats including SARIF, JUnit, CodeClimate, Checkstyle, SonarQube, and GitHub Actions, while updating existing formatters like Console, Compact, and XML to use the new data structure. Users will see improved compatibility with CI/CD platforms, better structured output for static analysis tools, and consistent handling of issue data across all report types.

src/Psalm/Report · high confidence

Emit all stubs discovered by Psalm during analysis

Psalm now automatically generates and emits stubs for all classes, interfaces, traits, functions, and constants discovered during analysis, excluding internal Psalm code and already-stubbed items. This ensures that the generated stubs accurately reflect the full scope of the analyzed codebase, including file-defined functions and constants, without requiring manual intervention.

src/Psalm/Internal/Stubs · high confidence

HTML entity functions now respect PHP 8.1+ default encoding flags

The new HtmlFunctionTainter component updates taint analysis for html\_entity\_decode, htmlspecialchars\_decode, htmlentities, and htmlspecialchars to account for PHP 8.1+ changes where the default encoding flags include ENT\_QUOTES. When these functions are called without an explicit second argument on PHP 8.1 or later, the analysis now correctly marks the output as tainted with both INPUT\_HTML and INPUT\_HAS\_QUOTES, whereas previous versions only marked INPUT\_HTML. This ensures more accurate security detection for quote-related injection vectors in modern PHP environments.

src/Psalm/Internal/Provider/AddRemoveTaints · high confidence

Internal refactoring of docblock and code-manipulation classes

Classes in the \Psalm\\Internal\\FileManipulation\ namespace (such as \ClassDocblockManipulator\, \FunctionDocblockManipulator\, \PropertyDocblockManipulator\, \FileManipulationBuffer\, and \CodeMigration\) have been moved from the public \Psalm\ namespace to the internal \Psalm\\Internal\ namespace. This change restricts these implementation details to internal use, meaning external tools or plugins should no longer rely on these specific classes for modifying PHP code or docblocks.

src/Psalm/Internal/FileManipulation · high confidence

Internal type alias representation classes introduced

The internal type alias system now uses dedicated classes (ClassTypeAlias, InlineTypeAlias, LinkableTypeAlias) to represent different alias types, replacing the previous approach. These classes are marked as immutable and internal, providing a more structured way to handle type alias data within Psalm's internal type resolution.

src/Psalm/Internal/Type/TypeAlias · medium confidence

Introduce AST-aware file differ for precise language server diffs

Psalm now uses a new set of internal classes in \src/Psalm/Internal/Diff\ to compute differences between PHP files. Instead of simple line-by-line comparison, the new \FileDiffer\ and \FileStatementsDiffer\ leverage the Myers diff algorithm on the PHP-Parser AST to distinguish between signature changes (e.g., method name, property type) and body changes. This allows the language server to provide more accurate diagnostics and refactoring suggestions by understanding the structural context of code changes rather than just text offsets.

src/Psalm/Internal/Diff · high confidence

Introduce new Amp-based parallel processing infrastructure

Psalm now uses a new internal parallel processing system built on the Amp library and the \Amp\\Parallel\ components. This change introduces a new \Fork\ namespace containing a \Pool\ for managing worker processes, a \ForkContext\ for handling inter-process communication (IPC) and serialization (including optional \igbinary\ support), and a suite of specific task classes (\AnalyzerTask\, \ScannerTask\, \InitAnalyzerTask\, \ShutdownAnalyzerTask\, etc.) that define the work units for code analysis and scanning. The \PsalmRestarter\ has been updated to manage opcache and extension settings specifically for this new parallel execution model.

src/Psalm/Internal/Fork · high confidence

Introduce specialized code location classes for docblocks, parse errors, and raw positions

Psalm now uses dedicated subclasses of CodeLocation—DocblockTypeLocation, ParseErrorLocation, and Raw—to provide more precise and context-aware location tracking. DocblockTypeLocation exposes the specific line number of a docblock type annotation, ParseErrorLocation accurately maps parser errors to their file positions and line numbers, and Raw provides a generic location based on file content offsets. These changes improve the accuracy of error reporting and code analysis by ensuring that location data reflects the specific context in which it was generated.

src/Psalm/CodeLocation · high confidence

Introduce specific exception classes for analysis errors

The \src/Psalm/Exception\ directory now contains a dedicated set of exception classes (such as \CircularReferenceException\, \UnpopulatedClasslikeException\, and \UnresolvableConstantException\) to replace generic error handling. This allows the tool to distinguish between different failure modes during static analysis, providing more precise error reporting and enabling better handling of specific scenarios like circular references or unpopulated class definitions.

src/Psalm/Exception · high confidence

Language server refactored to use internal protocol and client configuration classes

The language server implementation has been restructured to use new internal classes for handling client communication and configuration. A new ClientConfiguration class centralizes settings such as debounce times for file changes and options to enable or disable features like completions, hover, and diagnostics. Client communication is now managed through a dedicated ClientHandler and LanguageClient, which handle JSON-RPC requests and notifications. The server also introduces a PathMapper to translate file paths between the client and server environments, and a new Message class to standardize protocol message parsing and serialization.

src/Psalm/Internal/LanguageServer · high confidence

Modernized LSP progress reporting with token-based notifications

The progress reporting mechanism in the Language Server has been updated to use the standard LSP \$/progress\ notification protocol. The new \Progress\ class sends structured notifications containing a unique token and specific actions (begin, report, end), allowing clients to track multiple concurrent operations. A \LegacyProgress\ implementation is also provided for compatibility, which continues to use the older \telemetry/event\ notification method. This change ensures that progress updates are properly scoped and supported by LSP-compliant editors.

src/Psalm/Internal/LanguageServer/Client/Progress · high confidence

New internal client method handlers for diagnostics and workspace configuration

The Language Server Client now exposes dedicated internal classes (TextDocument and Workspace) to handle specific LSP protocol methods. The TextDocument class provides a handler for publishing diagnostics from the server to the client, respecting the client's configuration settings. The Workspace class adds a method to request configuration settings from the client, allowing the server to fetch specific configuration sections. These changes structure the client-side protocol handling more explicitly.

src/Psalm/Internal/LanguageServer/Client · high confidence

New plugin architecture and improved Shepherd reporting

This change introduces a new plugin registration model via the \PluginEntryPointInterface\ and \PluginRegistrationSocket\, replacing the previous \RegistrationInterface\ to allow plugins to declare custom scanners, analyzers, and file extensions early. It also adds new internal classes (\ArgTypeInferer\, \DynamicFunctionStorage\, \DynamicTemplateProvider\) to support dynamic function storage and template handling. Additionally, the Shepherd reporting mechanism has been updated to send a list of issues instead of an array with integer keys, include package versions in the payload, follow HTTP redirects, and output debug information to STDERR for better visibility of errors and SSL issues.

src/Psalm/Plugin · high confidence

Plugin event classes are now immutable and final

All event classes in the \src/Psalm/Plugin/EventHandler/Event\ directory have been converted to immutable, final value objects. Constructor properties are now declared as \private readonly\, and mutable setter methods (such as \setFileReplacements\ and \setStmt\) have been removed in favor of passing state through the constructor. This change ensures that event data cannot be modified after creation, providing a more stable and predictable interface for plugin developers hooking into the analysis lifecycle.

src/Psalm/Plugin/EventHandler/Event · high confidence

Psalm issue reporting model refactored to use typed classes with shortcodes

The internal mechanism for reporting static analysis issues has been overhauled: the previous array-based data structure is replaced by a hierarchy of typed classes (e.g., InvalidArgument, DeprecatedClass) under a new CodeIssue base. Each issue class now defines a SHORTCODE and ERROR\_LEVEL, enabling more granular filtering and consistent reporting. The base class also standardizes location and snippet data via CodeLocation and provides a toIssueData() method for structured output, improving reliability and maintainability of the analysis engine.

src/Psalm/Issue · high confidence

Refactor constant expression parsing into immutable value objects

The internal constant expression scanner has been refactored to use a set of new, immutable, and readonly classes (such as UnresolvedBinaryOp, UnresolvedTernary, and ClassConstant) to represent constant structures. This change improves type safety and immutability within the scanner, ensuring that constant expressions are handled more robustly during static analysis.

src/Psalm/Internal/Scanner/UnresolvedConstant · medium confidence

Refactor scanner internals into dedicated data classes and parsers

The scanner logic in src/Psalm/Internal/Scanner has been restructured to use specific data classes for docblock information, including ClassLikeDocblockComment, FunctionDocblockComment, VarDocblockComment, and ParsedDocblock, alongside a new DocblockParser and PhpStormMetaScanner. This change introduces support for new annotations such as @psalm-self-out, @psalm-if-this-is, @param-closure-this, @psalm-api, @psalm-internal, @psalm-yield, @psalm-inheritors, @psalm-stub-override, @psalm-no-seal-properties, @psalm-no-seal-methods, and @readonly, while also improving the handling of phpstorm.meta.php overrides and template tags.

src/Psalm/Internal/Scanner · high confidence

Refactor scope tracking into dedicated internal classes

Psalm now uses specific internal classes (CaseScope, FinallyScope, IfConditionalScope, IfScope, LoopScope, SwitchScope) to manage variable scope and type inference for different control structures, replacing the previous monolithic approach. This structural change improves the precision of type analysis for variables within if/else blocks, loops, switch statements, and finally blocks, leading to more accurate detection of undefined or reassigned variables. Also in this area: 7 commits (3 fixes) modifying src/Psalm/Internal/Scope.

src/Psalm/Internal/Scope · medium confidence · unverified

Refactor type parsing into dedicated ParseTree node classes

The internal type parser in src/Psalm/Internal/Type/ParseTree has been restructured to use specific, final classes for each parse tree node type (such as CallableTree, UnionTree, GenericTree, and Value). This change introduces a more explicit internal representation for parsed type structures, improving code clarity and maintainability for the type-checking engine without altering external behavior.

src/Psalm/Internal/Type/ParseTree · high confidence

Refactored control-flow analysis into dedicated block analyzers

The analysis of control-flow structures (if/else, switch, try/catch, and various loops) has been reorganized into dedicated, specialized classes (e.g., \IfElseAnalyzer\, \SwitchAnalyzer\, \TryAnalyzer\, \LoopAnalyzer\). This change improves the accuracy of type inference and variable tracking within these blocks, ensuring that variables defined inside a \try\ block are correctly marked as possibly undefined in \catch\ and \finally\ blocks, and that loop variables are properly reconciled after the loop exits. Users will see fewer false positives for unused variables and more precise type narrowing in complex conditional and loop structures. Also in this area: 28 commits (1 fix) modifying src/Psalm; 31 commits (4 fixes) modifying src/Psalm/Internal/Analyzer/Statements/Block; Improved type inference for ArrayAccess destructuring and precise taint reporting for stubbed parameters.

src/Psalm/Internal/Analyzer/Statements/Block · medium confidence · unverified

Refactored data-flow analysis to use immutable nodes and paths

The internal data-flow analysis engine has been refactored to use immutable structures for better determinism and thread-safety. DataFlowNode now uses a private constructor with factory methods, ensuring that node identities and their associated code locations are derived deterministically from the node's ID, which prevents non-deterministic behavior in multithreaded analysis. Additionally, a new immutable Path class has been introduced to represent taint flow paths, replacing previous mutable representations. These changes improve the reliability of taint analysis results across different execution environments.

src/Psalm/Internal/DataFlow · high confidence

Refactored progress reporting with new UI and rate-limiting

The progress output system has been restructured into a new class hierarchy (Progress, LongProgress, DefaultProgress, DebugProgress, VoidProgress) to improve clarity and performance. For users scanning large projects (over 1,500 files), the default progress bar now uses a horizontal Unicode bar that is rate-limited to update at most once every 0.1 seconds, reducing terminal flickering and I/O overhead. The output now clearly distinguishes between scanning and analyzing phases, and includes a visual progress bar with percentage completion. A VoidProgress implementation allows for completely silent operation when needed.

src/Psalm/Progress · high confidence

Robust JSON encoding with pretty-printing and invalid UTF-8 handling

The JSON reporting system now uses a dedicated encoder that supports pretty-printed output and automatically sanitizes invalid UTF-8 sequences in error messages. This prevents crashes when generating reports containing malformed strings, ensuring that JSON output is always valid and readable.

src/Psalm/Internal/Json · high confidence

Fixes

5 commits (3 fixes) fixing stubs/libraries/monolog

A fix in stubs/libraries/monolog — 5 commits (3 fixs), 1 file: “Add a library stub for the file and SSRF sinks of Monolog's stream and socket handlers”; “fix(stubs): declare the Monolog handlers that override the formatter contract \#13034”; “fix(stubs): don't restrict psr/log and Monolog logging methods \#13034”; and 2 more (refs \#13034).

stubs/libraries/monolog · medium confidence · unverified

Test coverage

1 commit adding/updating tests in tests/Storage; 128 commits adding/updating tests in tests/EndToEnd; 2 commits adding/updating tests in tests/Internal/ExecutionEnvironment; 2 commits adding/updating tests in tests/fixtures/GlobalOfAConfiguredClass; 25 commits adding/updating tests in tests/Taint; 4 commits adding/updating tests in tests/Config/Plugin/EventHandler/LocationlessNode; 47 commits adding/updating tests in tests/Internal/Provider; 63 commits adding/updating tests in tests/Internal; 8 commits adding/updating tests in tests/Internal/Stubs; Added comprehensive test coverage for template type analysis; Added comprehensive test suite for the Language Server; Added performance test fixtures for partial parsing benchmarks; Added taint graph test fixture; Added test coverage for FileScanner global variable handling; Added test coverage for loop control flow analysis; Added test fixture for SuicidalAutoloader; Added test fixture for destructive autoloader behavior; Added test fixture for error detection scenarios; Added test fixtures for class discovery in library directories; Added test fixtures for modular config support; Added test fixtures for plugin configuration and hook registration; Added test fixtures for plugin hook interfaces; Added test fixtures for shallow-scan extra files behavior; Added test fixtures for trait method resolution and function loading; Added test for partial taint analysis of inherited methods; Added test helper for progress output; Added test traits for code analysis validation; Added tests for codebase internal components; Added tests for declare statement analysis and issue documentation URL handling; Added tests for dynamic property and missing dependency analysis; Added tests for file update and caching behavior; Added tests for psalter code-manipulation capabilities; Added tests for return type providers; Added tests for the AddTaints plugin interface; Added tests for the Config subsystem; Expanded test coverage for static analysis features; Expanded test coverage for type reconciliation logic.

Housekeeping

Placeholder for PHPUnit build directory

An empty .gitkeep file was added to the build/phpunit directory to ensure the directory is tracked in version control.

build · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 56.0 → 65.6 (+9.6)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 75.7 → 75.8 (+0.1)
  • Architecture 85.9 → 88.8 (+2.9)
  • Maturity 70.8 → 71.3 (+0.5)
  • Readiness 43.7 → 62.6 (+18.9)
  • Security 59.3 → 61.8 (+2.5)

Resolved (157)

  • ArgumentsAnalyzer.analyze (cognitive 123) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php)
  • ArgumentsAnalyzer.analyze (cyclomatic 90) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php)
  • AssertionFinder.hasLessThanCountEqualityCheck (cognitive 18) (src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php)
  • AssertionFinder.hasLessThanCountEqualityCheck (cyclomatic 17) (src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php)
  • AssertionFinder.hasNonEmptyCountEqualityCheck (cognitive 18) (src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php)
  • AssertionFinder.hasNonEmptyCountEqualityCheck (cyclomatic 17) (src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php)
  • AssignmentAnalyzer.analyze (cognitive 142) (src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php)
  • AssignmentAnalyzer.analyze (cyclomatic 94) (src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php)
  • AtomicMethodCallAnalyzer.handleRegularMixins (cognitive 16) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/AtomicMethodCallAnalyzer.php)
  • AtomicMethodCallAnalyzer.handleTemplatedMixins (cognitive 37) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/AtomicMethodCallAnalyzer.php)
  • Cache.getItem (cognitive 17) (src/Psalm/Internal/Cache.php)
  • Cache.getItem (cyclomatic 16) (src/Psalm/Internal/Cache.php)
  • Change coupling: CallMap_72_delta.php ↔ CallMap_80_delta.php (dictionaries/override/CallMap_72_delta.php)
  • Change coupling: CallMap_74_delta.php ↔ CallMap_80_delta.php (dictionaries/override/CallMap_74_delta.php)
  • Change coupling: ClassLikeStorageCacheProvider.php ↔ FileStorageCacheProvider.php (src/Psalm/Internal/Provider/ClassLikeStorageCacheProvider.php)
  • Change coupling: ClassLikeStorageCacheProvider.php ↔ ParserCacheProvider.php (src/Psalm/Internal/Provider/ClassLikeStorageCacheProvider.php)
  • Change coupling: EvalAnalyzer.php ↔ AtomicPropertyFetchAnalyzer.php (src/Psalm/Internal/Analyzer/Statements/Expression/EvalAnalyzer.php)
  • Change coupling: EvalAnalyzer.php ↔ IncludeAnalyzer.php (src/Psalm/Internal/Analyzer/Statements/Expression/EvalAnalyzer.php)
  • Change coupling: TextDocument.php ↔ Workspace.php (src/Psalm/Internal/LanguageServer/Server/TextDocument.php)
  • ClassAnalyzer.analyze (cognitive 155) (src/Psalm/Internal/Analyzer/ClassAnalyzer.php)
  • …and 137 more

New (563)

  • AlgebraAnalyzer.findImplication (cognitive 37) (src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php)
  • AlgebraAnalyzer.findImplication (cyclomatic 17) (src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php)
  • Analyzer.updateFile (cognitive 17) (src/Psalm/Internal/Codebase/Analyzer.php)
  • AndAnalyzer.analyze (cyclomatic 30) (src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/AndAnalyzer.php)
  • ArgumentAnalyzer.getDispatchNode (cognitive 49) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentAnalyzer.php)
  • ArgumentAnalyzer.getDispatchNode (cyclomatic 27) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentAnalyzer.php)
  • ArgumentAnalyzer.getDispatchRoutes (cognitive 34) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentAnalyzer.php)
  • ArgumentAnalyzer.getDispatchRoutes (cyclomatic 18) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentAnalyzer.php)
  • ArgumentsAnalyzer.analyzeArguments (cognitive 107) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php)
  • ArgumentsAnalyzer.analyzeArguments (cyclomatic 80) (src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php)
  • ArithmeticOpAnalyzer.getBitwiseResultOfNonNegativeRanges (cognitive 17) (src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/ArithmeticOpAnalyzer.php)
  • ArithmeticOpAnalyzer.isChangeableByLoop (cognitive 33) (src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/ArithmeticOpAnalyzer.php)
  • ArithmeticOpAnalyzer.isChangeableByLoop (cyclomatic 23) (src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/ArithmeticOpAnalyzer.php)
  • ArrayAnalyzer.castArrayKeyType (cyclomatic 21) (src/Psalm/Internal/Analyzer/Statements/Expression/ArrayAnalyzer.php)
  • ArrayAssignmentAnalyzer.getKeyAt (cognitive 18) (src/Psalm/Internal/Analyzer/Statements/Expression/Assignment/ArrayAssignmentAnalyzer.php)
  • ArrayAssignmentAnalyzer.updateParentTypes (cognitive 37) (src/Psalm/Internal/Analyzer/Statements/Expression/Assignment/ArrayAssignmentAnalyzer.php)
  • ArrayAssignmentAnalyzer.updateParentTypes (cyclomatic 17) (src/Psalm/Internal/Analyzer/Statements/Expression/Assignment/ArrayAssignmentAnalyzer.php)
  • ArrayColumnReturnTypeProvider.castToArrayKey (cyclomatic 17) (src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayColumnReturnTypeProvider.php)
  • ArrayFetchAnalyzer.castInvalidOffsetTypes (cognitive 26) (src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php)
  • ArrayFetchAnalyzer.splitInvalidOffsetTypes (cognitive 17) (src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php)
  • …and 543 more

Changes since last survey

  • 300 commits — 231 feature/other, 69 fixes

By area

  • src/Psalm — 182 commits
  • (repo) — 90 commits
  • (root) — 4 commits
  • tests/ArrayAccessTest.php — 3 commits
  • tests/Loop — 3 commits
  • dictionaries/override — 2 commits
  • docs/annotating_code — 2 commits
  • stubs/PhpVersionedClasses.phpstub — 2 commits
  • tests/BinaryOperationTest.php — 2 commits
  • tests/PropertyTypeTest.php — 2 commits
  • docs/running_psalm — 1 commit
  • stubs/CoreGenericFunctions.phpstub — 1 commit
  • tests/ClassLoadOrderTest.php — 1 commit
  • tests/Internal — 1 commit
  • tests/SwitchTypeTest.php — 1 commit
  • tests/TaintTest.php — 1 commit
  • tests/Template — 1 commit
  • tests/TypeReconciliation — 1 commit

Notable commits

  • fix: Fix docblock spacing
  • fix: Fix explode() return type with a negative limit
  • fix: Fix false PossiblyUndefinedArrayOffset after a loop that breaks on isset()
  • fix: Fix self-analysis and a test whose hook body had a real issue
  • fix: Fix self-analysis issues
  • fix: Fix self-analysis of mayAssignAsAWhole()
  • fix: Keep native return types the inherited docblock coerces, fix ArrayObject sort stubs
  • fix: Keep only the null fix
  • fix: Merge branch 'master' of https://github.com/vimeo/psalm into fix-13969-unused-var-break-catch
  • fix: Merge branch 'master' of https://github.com/vimeo/psalm into fix-13969-unused-var-break-catch
  • fix: Merge condition writes a short circuit can skip, fix array_splice
  • fix: Merge master into fix-11143-nullsafe-not-null
  • fix: Merge pull request #12701 from jirkace/fix-11143-nullsafe-not-null
  • fix: Merge pull request #12738 from jirkace/fix-9960-coalesce-arrayaccess
  • fix: Merge pull request #13086 from jirkace/fix/8085-quoted-array-key-id
  • fix: Merge pull request #13131 from jirkace/fix/10177-duplicate-union-type
  • fix: Merge pull request #13385 from jirkace/fix/9289-switch-conditional-break
  • fix: Merge pull request #13785 from shu-chen-dot-ca/fix-13650-arrayaccess-self-destructure
  • fix: Merge pull request #13876 from alies-dev/fix/shape-part-of-intersection-is-not-a-mixed-receiver
  • fix: Merge pull request #13879 from orklah/fix-13739-byref-args
  • …and 280 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

vimeo/psalm was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 8ff70acd74e59e18580a409163ad09fa48f59260 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.