Cannot directly access class constant {CONST} of trait {TRAIT} defined at {FILE}:{LINE}

Cannot access private class constant {CONST} defined at {FILE}:{LINE}

Cannot access protected class constant {CONST} defined at {FILE}:{LINE}

Attempting to extend from final class {CLASS} defined at {FILE}:{LINE}

final class FinalClass
class A extends FinalClass {}

Attempting to extend from final internal class {CLASS}

class A extends Closure {}

Cannot access private method {METHOD} defined at {FILE}:{LINE}

Cannot access private method {METHOD} defined at {FILE}:{LINE} (if this call should be handled by __call, consider adding a @method tag to the class)

Cannot access protected method {METHOD} defined at {FILE}:{LINE}

Cannot access protected method {METHOD} defined at {FILE}:{LINE} (if this call should be handled by __call, consider adding a @method tag to the class)

Attempting to access attribute {CLASS} with non-public constructor {METHOD} defined at {FILE}:{LINE}. This will throw if ReflectionAttribute->newInstance() is called.

Cannot make non static method {METHOD}() static

Cannot make non static property {PROPERTY} into the static property {PROPERTY}

Declaration of class constant {CONST} overrides final constant {CONST} defined at {FILE}:{LINE}

Declaration of method {METHOD} overrides final method {METHOD} defined in {FILE}:{LINE}

Declaration of method {METHOD} overrides final method {METHOD} defined in trait in {FILE}:{LINE}. This is actually allowed in case of traits, even for final methods, but may lead to unexpected behavior

Declaration of method {METHOD} overrides final internal method {METHOD}

Declaration of phpdoc method {METHOD} is an unnecessary override of final method {METHOD} defined in {FILE}:{LINE}

Accessing own constructor directly via {CLASS}::__construct

Accessing non static property {PROPERTY} as static

class A { public $prop = 'value'; }
$x = A::$prop;

Cannot access private property {PROPERTY} defined at {FILE}:{LINE}

class C1 { private static $p = 42; }
print C1::$p;

Cannot access protected property {PROPERTY} defined at {FILE}:{LINE}

class C1 { protected static $p = 42; }
print C1::$p;

Accessing static property {PROPERTY} as non static

class A { public static $prop = 'value'; }
$x = (new A())->prop;

Cannot modify read-only magic property {PROPERTY} defined at {FILE}:{LINE}

Cannot modify read-only property {PROPERTY} defined at {FILE}:{LINE}

Cannot modify readonly property {PROPERTY} after initialization

Cannot modify {TYPE} property {PROPERTY} defined at {FILE}:{LINE} from {FILE}:{LINE}

Access level to {METHOD} must be compatible with {METHOD} defined in {FILE}:{LINE}

Access level to {METHOD} must be compatible with internal {METHOD}

Cannot make static method {METHOD}() defined in {FILE}:{LINE} non static

Cannot make static method {METHOD}() non static

Cannot make static property {PROPERTY} into the non static property {PROPERTY}

Cannot read write-only magic property {PROPERTY} defined at {FILE}:{LINE}

Cannot read write-only property {PROPERTY} defined at {FILE}:{LINE}

Attempting to inherit {CLASSLIKE} defined at {FILE}:{LINE} as if it were a {CLASSLIKE}

Attempting to inherit internal {CLASSLIKE} as if it were a {CLASSLIKE}

Access level to {CONST} must be compatible with {CONST} defined in {FILE}:{LINE}

Access level to {CONST} must be compatible with internal {CONST}

Access level to {PROPERTY} must be compatible with {PROPERTY} defined in {FILE}:{LINE}

Access level to {PROPERTY} must be compatible with internal {PROPERTY}

'{CONST}' is an invalid FQSEN for a constant

'{CONST}' has a reserved keyword in the constant name

Expression is unanalyzable or feature is unimplemented. Please create an issue at https://github.com/phan/phan/issues/new.

Unable to determine the method(s) which {METHOD} overrides, but Phan inferred that it did override something earlier. Please create an issue at https://github.com/phan/phan/issues/new with a test case.

Calling static method {METHOD} on a trait is deprecated, it should only be called on a class using the trait (in {CODE})

Accessing static property {PROPERTY} on a trait is deprecated, it should only be accessed on a class using the trait

Declaring a custom assert() function is a fatal error because the function has special semantics.

Declaring an autoloader with function __autoload() is a fatal error. Use spl_autoload_register() instead.

Using a default ({CODE}) that resolves to null does not cause the parameter ({PARAMETER}) to be nullable

Array and string offset access syntax with curly braces is no longer supported. Use square brackets instead. Seen for {CODE}

Fetching properties of enums in constant expressions (e.g. {CODE}) is only supported in PHP 8.2+.

Passing glue string after the array is deprecated for {FUNCTION}. Should this swap the parameters of type {TYPE} and {TYPE}?

Attribute #[Override] on {CLASS} is only supported in PHP {DETAILS}.

Readonly class {CLASS} is only supported in PHP 8.2+.

Cannot use {TYPE} as a standalone type before php 8.2.

Saw a parse notice: {DETAILS}

Trait {TRAIT} declares constant {CONST} which is only allowed in 8.2+

Cannot use {TYPE} as a type before php 8.2.

Typed class constant {CONST} is only supported in PHP 8.3+.

Unparenthesized '{CODE}' is deprecated. Use either '{CODE}' or '{CODE}'

The unset cast (in {CODE}) is a fatal error.

Only properties of enums can be fetched in constant expressions, {TYPE} given

Cannot access {CLASS} when not in object context

new parent;

Cannot access {CLASS} when not in object context, but code is using callable {METHOD}

Cannot use {CLASS} as type when not in object context in {FUNCTION}

Suspicious reference to magic constant {CODE}: {DETAILS}

Creating case-insensitive constants with define() is deprecated

Using a deprecated class {CLASS} defined at {FILE}:{LINE}{DETAILS}

Reference to deprecated class constant {CONST} defined at {FILE}:{LINE}{DETAILS}

Argument {INDEX} (${PARAMETER}) of type {TYPE} may be an object but passing objects to {FUNCTIONLIKE} has been deprecated in PHP 8.5

Saw deprecated encapsulated string variable syntax for {CODE}: {DETAILS}

Call to deprecated function {FUNCTIONLIKE} defined at {FILE}:{LINE}{DETAILS}

/** @deprecated  */
function f1() {}
f1();

Deprecated argument usage for function {FUNCTIONLIKE}: {DETAILS}

Call to deprecated function {FUNCTIONLIKE}{DETAILS}

Reference to deprecated constant {CONST}{DETAILS}

Implicit nullable parameters ({TYPE} {PARAMETER} = null) have been deprecated in PHP 8.4

Using a deprecated interface {INTERFACE} defined at {FILE}:{LINE}{DETAILS}

Saw deprecated partially supported callable {METHOD}. This was deprecated in PHP 8.2 and behaves inconsistently and can be called with call_user_func but not $callable() and the referenced class depends on context at call time. In some cases, [{CLASS}::class, {METHOD}] can be used instead.

Saw partially supported callable [{CODE}, {METHOD}]. This was deprecated in PHP 8.2. Invoking methods with alternative scopes can be done with ReflectionMethod::invoke or Closure::bindTo instead.

Reference to deprecated property {PROPERTY} defined at {FILE}:{LINE}{DETAILS}

Using a deprecated trait {TRAIT} defined at {FILE}:{LINE}{DETAILS}

Empty closure {FUNCTION}

Saw a foreach statement with empty iterable type {TYPE}

Saw a foreach statement with empty body over array of type {TYPE} (iterating has no side effects)

Empty function {FUNCTION}

Empty private method {METHOD}

Empty protected method {METHOD}

Empty public method {METHOD}

Saw a yield from statement with empty iterable type {TYPE}

Return value of {FUNCTION} with #[\NoDiscard] attribute is discarded - use (void) cast to suppress this warning

Unused array

[1,2,3];

Unused array offset fetch

Unused result of a binary '{OPERATOR}' operator

Unused result of a ({TYPE})({CODE}) cast

Unused closure

function () {};

Unused constant

const C = 42;
C;

Unused result of an empty({CODE}) check

Unused result of an encapsulated string literal

Unused result of an isset({CODE}) check

This match expression only has the default arm in {CODE}

The result of this match expression is not used and the arms have no side effects (except for possibly throwing UnhandledMatchError) in {CODE}

Unused result of new object creation expression in {CODE} (this may be called for the side effects of the non-empty constructor or destructor)

Unused result of new object creation expression in {CODE} (this is likely free of side effects - there is no known non-empty constructor or destructor)

Unused result of a numeric literal {SCALAR} near this line

Unused property

class C {
    public $p;
    function f() {
        $this->p;
    }
}

Saw a repeated silence operator in {CODE}

Unused result of a string literal {STRING_LITERAL} near this line

This switch statement only has the default case

Unused result of a ternary expression where the true/false results don't seem to have side effects

Unused result of a unary '{OPERATOR}' operator

Unused variable

$a = 42;
$a;

Providing an unused optional parameter ${PARAMETER} to {FUNCTIONLIKE} defined at {FILE}:{LINE}

Providing an unused optional parameter ${PARAMETER} to {FUNCTIONLIKE} defined at {FILE}:{LINE}

Possibly zero write references to PHPDoc @property {PROPERTY}

Possibly zero write references to private property {PROPERTY}

Possibly zero write references to protected property {PROPERTY}

Possibly zero write references to public property {PROPERTY}

Attempting to convert {TYPE} to a list using {FUNCTION} (it is already a list)

Short arrow function shadows variable ${VARIABLE} from the outer scope

Saw a do-while loop which probably has no side effects

Saw a for loop which probably has no side effects

Saw a foreach loop which probably has no side effects

Saw a while loop which probably has no side effects

Addition of {TYPE} + {TYPE} {CODE} is a suspicious way to add two lists. Some of the array fields from the left hand side will be part of the result, replacing the fields with the same key from the right hand side (this operator does not concatenate the lists)

Catch statement for {CLASSLIKE} is unreachable. An earlier catch statement at line {LINE} caught the ancestor class/interface {CLASSLIKE}

Possibly zero references to {TYPE} {CLASS}

class C {}

class C2 {}
$v = 'C2';
new $v;

$v2 = 'C' . (1 + 1);
new $v2;

Possibly zero references to {FUNCTION}

Possibly zero references to global constant {CONST}

Possibly zero references to function {FUNCTION}

Possibly zero references to PHPDoc @property {PROPERTY}

Possibly zero references to private class constant {CONST}

Possibly zero references to private method {METHOD}

Possibly zero references to private property {PROPERTY}

Possibly zero references to protected class constant {CONST}

Possibly zero references to protected method {METHOD}

Possibly zero references to protected property {PROPERTY}

Possibly zero references to public class constant {CONST}

Possibly zero references to public method {METHOD}

Possibly zero references to public property {PROPERTY}

Possibly zero references to use statement for constant {CONST} ({CONST})

Possibly zero references to use statement for function {FUNCTION} ({FUNCTION})

Possibly zero references to use statement for classlike/namespace {CLASSLIKE} ({CLASSLIKE})

Parameter ${PARAMETER} is never used

Closure use variable ${VARIABLE} is never used

Parameter ${PARAMETER} is never used

Unused goto label {CODE}

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Parameter ${PARAMETER} is never used

Possibly useless branch in a function where the return value must be used - all branches return values equivalent to {CODE} (previous return is at line {LINE})

Unused definition of variable ${VARIABLE}

Unused definition of variable ${VARIABLE} as a caught exception

Variable ${VARIABLE} for caught exception is declared as unused. Omit the variable instead.

Unreferenced definition of variable ${VARIABLE} as a global variable

Unused definition of variable ${VARIABLE} as a reference

Unreferenced definition of variable ${VARIABLE} as a static variable

Unused definition of variable ${VARIABLE} as the value of a foreach loop that included keys

The use statement for constant {CONST} has no effect

The use statement for function {FUNCTION} has no effect

The use statement for class/namespace {CLASS} in a namespace has no effect

The use statement for class/namespace {CLASS} in the global namespace has no effect

Addition of {TYPE} + {TYPE} {CODE} is probably unnecessary. Array fields from the left hand side will be used instead of each of the fields from the right hand side

Uses of ${VARIABLE} could probably be replaced with a literal or constant

Uses of ${VARIABLE} could probably be replaced with an empty array

Uses of ${VARIABLE} could probably be replaced with false or a named constant

Uses of ${VARIABLE} could probably be replaced with a literal or constant float

Uses of ${VARIABLE} could probably be replaced with literal integer or a named constant

Uses of ${VARIABLE} could probably be replaced with null or a named constant

Uses of ${VARIABLE} could probably be replaced with a literal or constant string

Uses of ${VARIABLE} could probably be replaced with true or a named constant

Possibly zero read references to PHPDoc @property {PROPERTY}

Possibly zero read references to private property {PROPERTY}

Possibly zero read references to protected property {PROPERTY}

Possibly zero read references to public property {PROPERTY}

Cannot mix named arguments and argument unpacking in {CODE}

Cannot repeat the same name for named arguments ({CODE}) and ({CODE})

Saw a call with arguments ({CODE}) and ({CODE}) passed to the same parameter of {FUNCTIONLIKE} defined at {FILE}:{LINE}

Saw a call with arguments ({CODE}) and ({CODE}) passed to the same parameter of {FUNCTIONLIKE}

Missing named argument for {PARAMETER} in call to {METHOD} defined at {FILE}:{LINE}

Missing named argument for {PARAMETER} in call to {METHOD}

Saw named argument for {PARAMETER} in call to {METHOD} declared with {COMMENT} defined at {FILE}:{LINE}

Saw likely use of named argument for unpacking {PARAMETER} of type {TYPE} in call to {METHOD} declared with {COMMENT} defined at {FILE}:{LINE}

First argument of class_alias() must be a name of user defined class ('{CLASS}' attempted)

Saw a parameter named ${PARAMETER}. If this was used to indicate that a parameter is unused to Phan, consider using @unused-param after a param comment, or suppressing unused parameter warnings, or renaming the parameter if backwards-compatibility for named parameters is not needed.

Saw a parameter named ${PARAMETER}. If this was used to indicate that a parameter is unused to Phan, consider using @unused-param after a param comment, or suppressing unused parameter warnings, or renaming the parameter if backwards-compatibility for named parameters is not needed.

Redefinition of parameter {PARAMETER}

Required parameter {PARAMETER} follows optional {PARAMETER}

function f2($p1 = null, $p2) {}

Declaration of {METHOD} should be compatible with {METHOD} defined in {FILE}:{LINE}{DETAILS}

Declaration of {METHOD} should be compatible with internal {METHOD}{DETAILS}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} has type '{TYPE}' which cannot replace original parameter with no type) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} is a non-reference parameter overriding a reference parameter) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} is a reference parameter overriding a non-reference parameter) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} is a non-variadic parameter replacing a variadic parameter) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} of type '{TYPE}' cannot replace original parameter of type '{TYPE}') defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (parameter #{INDEX} is a variadic parameter replacing a non-variadic parameter) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (method returning '{TYPE}' cannot override method returning '{TYPE}') defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (the method override accepts {COUNT} parameter(s), but the overridden method can accept {COUNT}) defined in {FILE}:{LINE}

Declaration of real/@method {METHOD} should be compatible with real/@method {METHOD} (the method override requires {COUNT} parameter(s), but the overridden method requires only {COUNT}) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} has type '{TYPE}' in the real signature which cannot replace original parameter with no type in the real signature) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} has type '{TYPE}' in the real signature which cannot replace original parameter with no type in the real signature)

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} is a non-reference parameter overriding a reference parameter) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} is a non-reference parameter overriding a reference parameter)

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} is a reference parameter overriding a non-reference parameter) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} is a reference parameter overriding a non-reference parameter)

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} is a non-variadic parameter replacing a variadic parameter) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} is a non-variadic parameter replacing a variadic parameter)

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} of real signature type '{TYPE}' cannot replace original parameter of real signature type '{TYPE}') defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} of type '{TYPE}' cannot replace original parameter of type '{TYPE}')

Declaration of {METHOD} should be compatible with {METHOD} (parameter #{INDEX} is a variadic parameter replacing a non-variadic parameter) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (parameter #{INDEX} is a variadic parameter replacing a non-variadic parameter)

Declaration of {METHOD} should be compatible with {METHOD} (method where the return type in the real signature is '{TYPE}' cannot override method where the return type in the real signature is '{TYPE}') defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (method where the return type in the real signature is '{TYPE}' cannot override method where the return type in the real signature is '{TYPE}')

Declaration of {METHOD} should be compatible with {METHOD} (the method override accepts {COUNT} parameter(s), but the overridden method can accept {COUNT}) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (the method override accepts {COUNT} parameter(s), but the overridden method can accept {COUNT})

Declaration of {METHOD} should be compatible with {METHOD} (the method override requires {COUNT} parameter(s), but the overridden method requires only {COUNT}) defined in {FILE}:{LINE}

Declaration of {METHOD} should be compatible with internal {METHOD} (the method override requires {COUNT} parameter(s), but the overridden method requires only {COUNT})

Argument {INDEX} (${PARAMETER}) is {TYPE} but {FUNCTIONLIKE} takes {TYPE} when argument {INDEX} is {TYPE}

Argument {INDEX} (${PARAMETER}) is {TYPE} but {FUNCTIONLIKE} takes {TYPE} when passed only one argument

The last argument to {FUNCTIONLIKE} must be of type {TYPE}

The second to last argument to {FUNCTIONLIKE} must be of type {TYPE}

Argument #{INDEX} of this call to {FUNCTIONLIKE} is typically a literal or constant but isn't, but argument #{INDEX} (which is typically a variable) is a literal or constant. The arguments may be in the wrong order.

Call with {COUNT} arg(s) to {FUNCTIONLIKE} which requires {COUNT} arg(s) defined at {FILE}:{LINE}

function f6($i) {}
f6();

Call with {COUNT} arg(s) to {FUNCTIONLIKE} (as a provided callable) which requires {COUNT} arg(s) defined at {FILE}:{LINE}

Call with {COUNT} arg(s) to {FUNCTIONLIKE} which has phpdoc indicating it requires {COUNT} arg(s) (${PARAMETER} is mandatory) defined at {FILE}:{LINE}

Call with {COUNT} arg(s) to {FUNCTIONLIKE} which requires {COUNT} arg(s)

strlen();

Call with {COUNT} or more arg(s) to {FUNCTIONLIKE} which requires {COUNT} arg(s). This may throw an ArgumentCountError if there are too few args at runtime.

Call with {COUNT} or more arg(s) to {FUNCTIONLIKE} which requires {COUNT} arg(s) defined at {FILE}:{LINE}. This may throw an ArgumentCountError if there are too few args at runtime.

Call with {COUNT} arg(s) to {FUNCTIONLIKE} which only takes {COUNT} arg(s) defined at {FILE}:{LINE}

function f7($i) {}
f7(1, 2);

Call with {COUNT} arg(s) to {FUNCTIONLIKE} (As a provided callable) which only takes {COUNT} arg(s) defined at {FILE}:{LINE}

Call with {COUNT} arg(s) to {FUNCTIONLIKE} which only takes {COUNT} arg(s). This would throw an ArgumentCountError.

strlen('str', 42);

Call with {COUNT} or more args to {FUNCTIONLIKE} which only takes {COUNT} arg(s) defined at {FILE}:{LINE} (argument unpacking was used)

Call with {COUNT} or more args to {FUNCTIONLIKE} which only takes {COUNT} arg(s) (argument unpacking was used)

Argument {INDEX} is {TYPE} but {FUNCTIONLIKE} takes {TYPE}

Saw positional argument ({CODE}) after a named argument {CODE}

Passing named argument to a variadic parameter ${PARAMETER} of the same name in a call to {METHOD}. This will set the array offset "{PARAMETER}" of the resulting variadic parameter, not the parameter itself (suppress this if this is deliberate).

Passing named argument {CODE} to the variadic parameter of the internal function {METHOD}. Except for a few internal methods that call methods/constructors dynamically, this is usually not supported by internal functions.

Saw likely use of named arguments in argument unpacking for {PARAMETER} of type {TYPE} passed to an internal function {FUNCTION}. Except for a few internal methods that call methods/constructors dynamically, this is usually not supported by internal functions.

Saw a call with undeclared named argument ({CODE}) to {FUNCTIONLIKE} defined at {FILE}:{LINE}

Saw a call with undeclared named argument ({CODE}) to {FUNCTIONLIKE}

Duplicate declaration of static variable ${VARIABLE} in {FUNCTIONLIKE} - previously declared at {FILE}:{LINE}

{CLASS} and {CLASS} define the same constant ({CONST}) in the composition of {CLASS}. However, the definition differs and is considered incompatible. Class was composed in {FILE} on line {LINE}

Declaration of {METHOD} must be compatible with {METHOD} in {FILE} on line {LINE}

{TRAIT} and {TRAIT} define the same property ({PROPERTY}) in the composition of {CLASS}, as the types {TYPE} and {TYPE} respectively. However, the definition differs and is considered incompatible. Class was composed in {FILE} on line {LINE}

{CLASS} defined at {FILE}:{LINE} was previously defined as {CLASS} at {FILE}:{LINE}

class C15 {}
class C15 {}

{CLASS} aliased at {FILE}:{LINE} was previously defined as {CLASS} at {FILE}:{LINE}

Class constant {CONST} defined at {FILE}:{LINE} was previously defined at {FILE}:{LINE}

{CLASS} defined at {FILE}:{LINE} was previously defined as {CLASS} internally

class DateTime {}

Function {FUNCTION} defined at {FILE}:{LINE} was previously defined at {FILE}:{LINE}

function f9() {}
function f9() {}

Function {FUNCTION} defined at {FILE}:{LINE} was previously defined internally

function strlen() {}

Property ${PROPERTY} defined at {FILE}:{LINE} was previously defined at {FILE}:{LINE}

{CLASS} extends {CLASS} declared at {FILE}:{LINE} which is also declared at {FILE}:{LINE}. This may lead to confusing errors. It may be possible to exclude the class that isn't used with exclude_file_list.

{CLASS} inherits {INTERFACE} declared at {FILE}:{LINE} which is also declared at {FILE}:{LINE}. This may lead to confusing errors.

{CLASS} uses {TRAIT} declared at {FILE}:{LINE} which is also declared at {FILE}:{LINE}. This may lead to confusing errors.

Enum case {CONST} has the same value({SCALAR}) as a previous declared enum case {CONST} defined at {FILE}:{LINE}

Potentially calling an abstract static method {METHOD} in {CODE}

Potentially calling an abstract static method {METHOD} with static:: in {CODE} (the calling static method's class scope may be an abstract class)

Potentially calling an abstract static method {METHOD} on a trait in {CODE}, if the caller's method is called on the trait instead of a concrete class using the trait

Static call to non-static method {METHOD} defined at {FILE}:{LINE}. This would throw an Error.

class C19 { function f() {} }
C19::f();

Saw access to potentially inherited class element with {CODE} in a function that also uses static variables. PHP consistently uses one set of static variables per method declaration and the same method may end up write different values to static variables or do different things after reading static variables in different inherited classes. (This is a simple heuristic, suppress the issue if this is a false positive)

Static property {PROPERTY} is declared to have type {TYPE}, but the only instance is shared among all subclasses (Did you mean {TYPE})

Saw attribute {TYPE} which was declared without {CODE}

Saw attribute with fqsen {TYPE} which was a {CODE} instead of a class

Saw attribute {CLASS} which was not declared as \Attribute::IS_REPEATABLE in the class definition at {FILE}:{LINE} but had a repeat declaration on line {LINE}

Saw use of attribute {CLASS} declared at {FILE}:{LINE} which supports being declared on {DETAILS} but it was declared on {CODE} which requires an attribute declared to support {DETAILS}

Attribute {CLASS} declared at {FILE}:{LINE} supports {DETAILS} but was used on constructor promoted property {CODE}. Promoted properties require attributes to support both \Attribute::TARGET_PARAMETER and \Attribute::TARGET_PROPERTY for full compatibility

Using {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The left hand side may be unnecessary.

Using {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The left hand side may be unnecessary. (in the global scope - this is likely a false positive)

Using {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The left hand side may be unnecessary. (in a loop body - this is likely a false positive)

Using non-null {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The right hand side may be unnecessary.

Using non-null {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The right hand side may be unnecessary. (in the global scope - this is likely a false positive)

Using non-null {CODE} of type {TYPE} as the left hand side of a null coalescing (??) operation. The right hand side may be unnecessary. (in a loop body - this is likely a false positive)

Using {CODE} ?? null seems unnecessary - the expression appears to always be defined

Class constant {CONST} is declared with type {TYPE} which is not covariant with type {TYPE} inherited from {CLASSLIKE} (constant types must be invariant or covariant)

Saw {CODE} with a divisor of type {TYPE}

Enum {ENUM} is not allowed to declare instance or static properties but it contains property ${PROPERTY} declared at {FILE}:{LINE}

Classlike {CLASSLIKE} cannot implement {INTERFACE}

Enum {ENUM} is not allowed to have the magic method {METHOD} declared at {FILE}:{LINE}

Impossible attempt to cast {CODE} of type {TYPE} to {TYPE}

Impossible attempt to cast {CODE} of type {TYPE} to {TYPE} in the global scope (may be a false positive)

Impossible attempt to cast {CODE} of type {TYPE} to {TYPE} in a loop body (may be a false positive)

Intersection type {TYPE} contains part {TYPE} which cannot cast to the declared type {TYPE}

Impossible attempt to check if {CODE} of type {TYPE} is identical to {CODE} of type {TYPE}

Impossible attempt to check if {CODE} of type {TYPE} is identical to {CODE} of type {TYPE} in the global scope (likely a false positive)

Impossible attempt to check if {CODE} of type {TYPE} is identical to {CODE} of type {TYPE} in a loop body (likely a false positive)

Impossible comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' (the comparison is always false)

Impossible comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in the global scope (the comparison is always false, likely a false positive)

Impossible comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in a loop (the comparison is always false, likely a false positive)

Declaration of {PROPERTY} of real type {TYPE} is incompatible with inherited property {PROPERTY} of real type {TYPE} defined at {FILE}:{LINE}

The loop condition {CODE} of type {TYPE} is always {TYPE} and nothing seems to exit the loop

{FUNCTIONLIKE} is calling itself in a way that may cause infinite recursion.

Saw enum {ENUM} that declares no enum cases but contains instance method {METHOD} declared at {FILE}:{LINE}

Attempting to use a mixin of invalid or missing type {TYPE}

{PARAMETER} is variadic in comment, but not variadic in param ({PARAMETER})

{PARAMETER} is not variadic in comment, but variadic in param ({PARAMETER})

Saw {CODE} with modulus of type {TYPE}

Call to method {METHOD} on non-class type {TYPE}

$v8 = null;
$v8->f();

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible) defined at {FILE}:{LINE}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible)

Assigning {CODE} of type {TYPE} to property but {PROPERTY} is {TYPE} ({TYPE} is incompatible)

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE} ({TYPE} is incompatible)

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible) defined at {FILE}:{LINE}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible)

Assigning {CODE} of type {TYPE} to property but {PROPERTY} is {TYPE} ({TYPE} is incompatible)

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE} ({TYPE} is incompatible)

The loop condition {CODE} does not seem to change within the loop and nothing seems to exit the loop

{FUNCTIONLIKE} is calling itself with the same parameters it was called with. This may cause infinite recursion (Phan does not check for changes to global or shared state).

Call to method {METHOD} on type {TYPE} that could be a non-object

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible) defined at {FILE}:{LINE}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} ({TYPE} is incompatible)

Assigning {CODE} of type {TYPE} to property but {PROPERTY} is {TYPE} ({TYPE} is incompatible)

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE} ({TYPE} is incompatible)

Saw {CODE} exponentiating to a power of type {TYPE} (the result will always be 1)

Cannot override final property hook {PROPERTY}::{METHOD} defined at {FILE}:{LINE}

Property hook {PROPERTY}::{METHOD} parameter {PARAMETER} has type {TYPE} which is incompatible with property type {TYPE}

Property hook {PROPERTY}::{METHOD} returns {CODE} of type {TYPE} but property is declared as {TYPE}

Redundant attempt to cast {CODE} of type {TYPE} to {TYPE}

Redundant attempt to cast {CODE} of type {TYPE} to {TYPE} in the global scope (likely a false positive)

Redundant attempt to cast {CODE} of type {TYPE} to {TYPE} in a loop body (likely a false positive)

Redundant comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' (the comparison is always true)

Redundant comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in the global scope (the comparison is always true, likely a false positive)

Redundant comparison of {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in a loop (the comparison is always true, likely a false positive)

{FUNCTION}() statement was passed a relative path {STRING_LITERAL} instead of an absolute path

Suspicious loop appears to {DETAILS} after each iteration in {CODE}, but the loop condition is {CODE}

Suspicious attempt to check if {CODE} of type {TYPE} is truthy/falsey. This contains both objects/arrays and scalars

Suspicious attempt to check if {CODE} of type {TYPE} is truthy/falsey. This is false both for '' and '0'

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}'

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in the global scope (likely a false positive)

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE} with operator '{OPERATOR}' in a loop (likely a false positive)

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE}

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE} in the global scope (likely a false positive)

Suspicious attempt to compare {CODE} of type {TYPE} to {CODE} of type {TYPE} in a loop body (likely a false positive)

Invalid array operand provided to operator '{OPERATOR}' between types {TYPE} and {TYPE}

Suspicious array access to {CODE} of type {TYPE}

$a = false; if($a[1]) {}

Suspicious array access to {CODE} of type null

Suspicious array access to {CODE} of nullable type {TYPE}

Suspicious attempt to unset an offset of a value {CODE} of type {TYPE}

array to {TYPE} comparison

if ([1, 2] == 'string') {}

Using ordering comparison operator with an object of type {TYPE} and a non-object of type {TYPE} will throw a TypeError in PHP 8.0+

{TYPE} to array comparison

if (42 == [1, 2]) {}

Saw code asserting that an expression has a class, but that class is an invalid/impossible FQSEN {STRING_LITERAL}

Saw code asserting that an expression has a class, but saw an invalid/impossible union type {TYPE} (expected {TYPE})

array to {TYPE} conversion

Saw a call to an internal function {FUNCTION}() with what would be invalid arguments in strict mode, when trying to infer the return value literal type: {DETAILS}

Saw an error when attempting to infer the type of expression {CODE}: {DETAILS}

Expected an object instance but saw expression {CODE} with type {TYPE}

Expected an object instance or the name of a class but saw expression {CODE} with type {TYPE}

Expected an object instance when accessing an instance property, but saw an expression {CODE} with type {TYPE}

Expected an object instance when accessing an instance property, but saw an expression {CODE} with type {TYPE}

Expected an object instance or a class name when accessing a static property, but saw an expression {CODE} with type {TYPE}

Instantiation of abstract class {CLASS}

abstract class D {} (new D);

Potential instantiation of abstract class {CLASS} (not an issue if this method is only called from a non-abstract subclass)

Saw instantiation of enum {ENUM}

Instantiation of interface {INTERFACE}

interface E {} (new E);

Instantiation of trait {TRAIT}

Potential instantiation of trait {TRAIT} (not an issue if this method is only called from a non-abstract class using the trait)

Saw array key {CODE} with key type {TYPE} but expected a value that could cast to int|string

Saw array key {CODE} with key value {SCALAR} but expected a value that could cast to int|string

Invalid non-int/non-string operand provided to operator '{OPERATOR}' between types {TYPE} and {TYPE}

Probably unused assignment to function result {CODE} for function returning {TYPE}

Saw type {TYPE} which cannot be a callable

In a place where phan was expecting a callable, saw an array with an unexpected key for element #{INDEX} (expected [$class_or_expr, $method_name])

In a place where phan was expecting a callable, saw an array of size {COUNT}, but callable arrays must be of size 2

Method name of callable must be a string, got {TYPE}

In a place where phan was expecting a callable, saw a two-element array with a class or expression with an unexpected type {TYPE} (expected a class type or string). Method name was {METHOD}

Expected an object to be passed to clone() but got {TYPE}

Invalid @phan-closure-scope: expected a class name, got {TYPE}

Saw a class constant fetch with a name of type {TYPE} but expected the name to be a string

Invalid offset {SCALAR} of {CODE} of array type {TYPE}

Invalid offset {SCALAR} of {CODE} of array type {TYPE} in an array destructuring assignment

Eval statement was passed an invalid expression of type {TYPE} (expected a string)

Invalid value {CODE} of type {TYPE} in an array destructuring assignment, expected {TYPE}

Found an instanceof class name {CODE} of type {TYPE}, but class name must be a valid object or a string

Invalid operator: right operand is array and left is not

Invalid operator: left operand of {OPERATOR} is {TYPE} (expected array or number)

Invalid operator: left operand of {OPERATOR} is {TYPE} (expected int|string)

Invalid operator: left operand of {OPERATOR} is {TYPE} (expected int)

Invalid operator: left operand of {OPERATOR} is {TYPE} (expected number)

Instance method name must be a string, got {TYPE}

Operand {CODE} of type {TYPE} to modulo (%%) operator is implicitly converted to int (deprecated in PHP 8.1)

Saw a dynamic usage of an instance property with a name of type {TYPE} but expected the name to be a string

Require statement was passed an invalid expression of type {TYPE} (expected a string)

Invalid operator: left operand is array and right is not

Invalid operator: right operand of {OPERATOR} is {TYPE} (expected array or number)

Invalid operator: right operand of {OPERATOR} is {TYPE} (expected int|string)

Invalid operator: right operand of {OPERATOR} is {TYPE} (expected int)

Invalid operator: right operand of {OPERATOR} is {TYPE} (expected number)

Static method name must be a string, got {TYPE}

Saw a dynamic usage of a static property with a name of type {TYPE} but expected the name to be a string

{FUNCTIONLIKE} can throw {CODE} of type {TYPE} here which can't cast to {TYPE}

@throws annotation of {FUNCTIONLIKE} has suspicious interface type {TYPE} for an @throws annotation, expected class (PHP allows interfaces to be caught, so this might be intentional)

@throws annotation of {FUNCTIONLIKE} has invalid trait type {TYPE}, expected a class

@throws annotation of {FUNCTIONLIKE} has invalid non-object type {TYPE}, expected a class

@throws annotation of {FUNCTIONLIKE} has suspicious class type {TYPE}, which does not extend Error/Exception

{FUNCTIONLIKE} is declared to have a parameter ${PARAMETER} with a real type of trait {TYPE} (expected a class or interface or built-in type)

Expected a class or interface (or built-in type) to be the real return type of {FUNCTIONLIKE} but got trait {TRAIT}

Invalid operator: unary operand of {STRING_LITERAL} is {TYPE} (expected number that can fit in an int, or string)

Invalid operator: unary operand of {STRING_LITERAL} is {TYPE} (expected int or string or float)

Invalid operator: unary operand of {STRING_LITERAL} is {TYPE} (expected number)

Yield from statement was passed an invalid expression {CODE} of type {TYPE} (expected Traversable/array)

Found a return statement with a value in the implementation of the magic method {METHOD}, expected void return type

// (PHP ignores the return value of some magic methods, such as __set)
class A { public function __set() { return true; } }

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} defined at {FILE}:{LINE}

function f8(int $i) {}
f8('string');

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE}

strlen(42);

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} takes {TYPE}{DETAILS}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} takes {TYPE}{DETAILS}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} defined at {FILE}:{LINE} (expected type to be non-nullable)

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} (expected type to be non-nullable)

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} takes {TYPE}{DETAILS} defined at {FILE}:{LINE} (the inferred real argument type has nothing in common with the parameter's phpdoc type)

Argument {INDEX} is property {PROPERTY} with type {TYPE} but {FUNCTIONLIKE} takes a reference of type {TYPE}

Argument {INDEX} is property {PROPERTY} with type {TYPE}{DETAILS} but {FUNCTIONLIKE} takes a reference of type {TYPE}{DETAILS}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} takes {TYPE}{DETAILS} defined at {FILE}:{LINE}

Argument {INDEX} (${PARAMETER}) is {CODE} of type {TYPE} but {FUNCTIONLIKE} takes {TYPE} defined at {FILE}:{LINE} (expected type to be the same or a subtype, but saw a supertype instead)

Attempting an array destructing assignment with a key of type {TYPE} but the only key types of the right-hand side are of type {TYPE}

Unexpected mix of int and string operands provided to operator '{OPERATOR}' between types {TYPE} and {TYPE} (expected one type but not both)

Constant {CONST} is declared with type {TYPE} but has value {CODE} of type {TYPE}

Constant {CONST} is declared with type never which always results in a compile error

Doc-block of ${PARAMETER} in {METHOD} contains phpdoc param type {TYPE} which is incompatible with the param type {TYPE} declared in the signature

Doc-block of ${PARAMETER} in {METHOD} is phpdoc param type {TYPE} which is not a permitted replacement of the nullable param type {TYPE} declared in the signature ('?T' should be documented as 'T|null' or '?T')

Doc-block of {METHOD} contains declared return type {TYPE} which is incompatible with the return type {TYPE} declared in the signature

Doc-block of {METHOD} has declared return type {TYPE} which is not a permitted replacement of the nullable return type {TYPE} declared in the signature ('?T' should be documented as 'T|null' or '?T')

Default value for {TYPE} ${PARAMETER} can't be {TYPE}

Default value for {TYPE} ${PARAMETER} can't be {TYPE} because the parameter contains intersection types

When appending to a value of type {TYPE}, found an array access index of type {TYPE}, but expected the index to be of type {TYPE}

Assigning to an empty array index of a value of type {TYPE}, but expected the index to exist and be of type {TYPE}

When fetching an array index from a value of type {TYPE}, found an array index of type {TYPE}, but expected the index to be of type {TYPE}

When fetching an array index from a value of type {TYPE}, found an array index of type {TYPE}, but expected the index to be of the non-nullable type {TYPE}

{TYPE} passed to foreach instead of array

foreach (null as $i) {}

Yield statement has a key {CODE} with type {TYPE} but {FUNCTIONLIKE} is declared to yield keys of type {TYPE} in {TYPE}

Yield statement has a value {CODE} with type {TYPE} but {FUNCTIONLIKE} is declared to yield values of type {TYPE} in {TYPE}

Assigning {CODE} of type {TYPE} to property but {PROPERTY} is {TYPE}

function f(int $p = false) {}

{CODE} of type {TYPE} may end up assigned to property {PROPERTY} of type {TYPE} by reference at {FILE}:{LINE}

Default value for {TYPE} ${PROPERTY} can't be {CODE} of type {TYPE} based on phpdoc types

Default value for {TYPE} ${PROPERTY} can't be {CODE} of type {TYPE}

Assigning {CODE} of type {TYPE}{DETAILS} to property but {PROPERTY} is {TYPE}{DETAILS} (the inferred real assigned type has nothing in common with the declared phpdoc property type)

Assigning {CODE} of type {TYPE}{DETAILS} to property but {PROPERTY} is {TYPE}{DETAILS}

{CODE} of type {TYPE} may end up assigned to property {PROPERTY} of type {TYPE} by reference at {FILE}:{LINE}

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE}

class G { /** @param string $s */ function f($s) : int { return $s; } }

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE} (expected returned value to be non-nullable)

Returning {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} is declared to return {TYPE}{DETAILS} (the inferred real return type has nothing in common with the declared phpdoc return type)

Returning {CODE} of type {TYPE}{DETAILS} but {FUNCTIONLIKE} is declared to return {TYPE}{DETAILS}

class G { function f() : int { return 'string'; } }

Returning {CODE} of type {TYPE} but {FUNCTIONLIKE} is declared to return {TYPE} (saw a supertype instead of a subtype)

Attempting to unpack a value of type {TYPE} which does not contain any subtypes of iterable (such as array or Traversable)

Method {METHOD} is declared to return {TYPE} in phpdoc but has no return value

class H { function f() : int {} }

Method {METHOD} is declared to return {TYPE} in its real type signature but has no return value

Saw attempt to modify {TYPE} {CLASS}'s property ${PROPERTY} declared at {FILE}:{LINE} (immutability of properties is enforced at runtime)

Class {TYPE} was passed to foreach, but it does not extend Traversable and none of its declared properties are accessible from this context. (This check excludes dynamic properties)

Class {TYPE} was passed to foreach, but it does not extend Traversable and doesn't have any declared properties. (This check excludes dynamic properties)

Only variables can be passed by reference at argument {INDEX} of {FUNCTIONLIKE}

class F { static function f(&$v) {} } F::f('string');

Only variables can be returned by reference in {FUNCTIONLIKE}

Suspicious attempt to unset class {TYPE}'s property ${PROPERTY} declared at {FILE}:{LINE} (This can be done, but is more commonly done for dynamic properties and Phan does not expect this)

Must call parent::__construct() from {CLASS} which extends {CLASS}

Saw type {TYPE} which is possibly not a callable

Expected an object to be passed to clone() but got possible non-object {TYPE}

Possibly invalid offset {SCALAR} of {CODE} of array type {TYPE}

Suspicious argument {CODE} of type {TYPE} for an echo/print statement

Indirect variable ${(expr)} has invalid inner expression type {TYPE}, expected string/integer

Class {TYPE} was passed to foreach, but it does not extend Traversable. This may be intentional, because some of that class's declared properties are accessible from this context. (This check excludes dynamic properties)

Suspicious type {TYPE} of a variable or expression {CODE} used to build a string. (Expected type to be able to cast to a string)

Saw enum case {CONST} with a value of type {TYPE} that did not match expected type {TYPE}

Cannot use void return value {CODE} as a function argument

Cannot assign void return value

class A { /** @return void */ function v() {} }
$a = (new A)->v();

Suspicious use of void return value {CODE} where a value is expected

Trait alias {METHOD} has an ambiguous source method {METHOD} with more than one possible source trait. Possibilities: {TRAIT}

non-abstract class {CLASS} contains abstract method {METHOD} declared at {FILE}:{LINE}

non-abstract class {CLASS} contains abstract internal method {METHOD}

Possible call to a function '{FUNCTIONLIKE}' with an empty FQSEN.

Possible use of a classlike '{CLASSLIKE}' with an empty FQSEN.

Empty file {FILE}

Possible call to a function '{FUNCTIONLIKE}' with an invalid FQSEN.

Possible use of a classlike '{CLASSLIKE}' with an invalid FQSEN.

Required file {FILE} is not a file

Missing required file {FILE}

Reference to parent of class {CLASS} that does not extend anything

class F { function f() { $v = parent::f(); } }

Global variable ${VARIABLE} is possibly undeclared

Call to possibly undeclared method {METHOD} on type {TYPE} ({TYPE} does not declare the method)

Reference to possibly undeclared property {PROPERTY} of expression of type {TYPE} ({TYPE} does not declare that property)

Reference to possibly undeclared property {PROPERTY} of expression of type {TYPE} (instances of {CLASS} do not declare that property)

Variable ${VARIABLE} is possibly undeclared

if ($cond) { $var = expr; }
// ...
if ($cond) { use($var); }

Attempting to read property {PROPERTY} which was unset in the current scope

Required trait {TRAIT} for trait adaptation was not added to class

trait T1 {}
trait T2 {}
class A {
	use T1 {T2::foo as bar;}
}

Reference to parent from trait {TRAIT}

trait T { function f() { return parent::f(); } }

Trait {TRAIT} requires using class {CLASS} to extend {TYPE}

Trait {TRAIT} requires using class {CLASS} to implement {TYPE}

Alias {METHOD} was defined for a method {METHOD} which does not exist in trait {TRAIT}

Reference to undeclared class {CLASS}

Reference to undeclared class {CLASS} for the original class of a class_alias for {CLASS}

Reference to undeclared class {CLASS} in an attribute

Catching undeclared class {CLASS}

try {} catch (Undef $exception) {}

Reference to constant {CONST} from undeclared class {CLASS}

Reference to undeclared class {CLASS} in callable {METHOD}

Checking instanceof against undeclared class {CLASS}

$v = null;
if ($v instanceof Undef) {}

Call to method {METHOD} from undeclared class {CLASS}

function g(Undef $v) { $v->f(); }

Reference to instance property {PROPERTY} from undeclared class {CLASS}

Reference to undeclared class {CLASS}

Reference to static property {PROPERTY} from undeclared class {CLASS}

Reference to undeclared class {CLASS} in @phan-closure-scope

Reference to undeclared constant {CONST}. This would throw an Error.

$v7 = UNDECLARED_CONSTANT;

Reference to undeclared class constant {CONST}

Class extends undeclared class {CLASS}

class E extends UndeclaredClass {}

Call to undeclared function {FUNCTION}

some_missing_function();

Call to undeclared function {FUNCTION} in callable

Global variable ${VARIABLE} is undeclared

Class implements undeclared interface {INTERFACE}

class C17 implements UndeclaredInterface {}

Possible attempt to access missing magic method {FUNCTIONLIKE} of '{CLASS}'

Reference to magic constant {CONST} that is undeclared in the current scope: {DETAILS}

Call to undeclared method {METHOD}

Call to undeclared method {METHOD} in callable. Possible object type(s) for that method are {TYPE}

Reference to undeclared property {PROPERTY}

class C {}
$v = (new C)->undef;

Static call to undeclared method {METHOD}

C::staticMethod();

Reference to undeclared static method {METHOD} in callable

Static property '{PROPERTY}' on {CLASS} is undeclared

class C22 {}
$v11 = C22::$p;

Variable ${VARIABLE} is undeclared

Class uses undeclared trait {TRAIT}

Class constant {CONST} has undeclared class type {TYPE}

Parameter ${PARAMETER} has undeclared type {TYPE}

function f(Undef $p) {}

Property {PROPERTY} has undeclared type {TYPE}

class D { /** @var Undef */ public $p; }

Return type of {METHOD} is undeclared type {TYPE}

@throws type of {METHOD} has undeclared type {TYPE}

Variable ${VARIABLE} is undeclared

Variable ${VARIABLE} was undeclared, but it is being used as the left-hand side of an assignment operation

Variable ${VARIABLE} was undeclared, but array fields are being added to it.

Non-variables ({CODE}) not allowed within use clause

Missing template parameter for type {TYPE} on constructor for generic class {CLASS} defined at {FILE}:{LINE}

Global variable {VARIABLE} may not be assigned an instance of a generic class

Class {CLASS} must substitute all {COUNT} template parameters when inheriting {CLASS} (found {COUNT}) defined at {FILE}:{LINE} (use @extends or @inherit)

Duplicate type false is redundant in union type {TYPE} (bool already includes false)

Duplicate type true is redundant in union type {TYPE} (bool already includes true)

Type {TYPE} contains both true and false - bool should be used instead

constant {CONST} may not have a template type

Template type {TYPE} of {CLASS} must be compatible with {TYPE}, but {TYPE} was provided in {CLASS}

Template type {TYPE} is already declared in this comment

Template type {TYPE} not declared in parameters of function/method {FUNCTIONLIKE} (or Phan can't extract template types for this use case)

Template type {TYPE} not used in return value of function/method {FUNCTIONLIKE}

Template type {TYPE} is already declared in the containing class

static method {METHOD} does not declare template type in its own comment and may not use the template type of class instances

static property {PROPERTY} may not have a template type

Template type {TYPE} declared {VARIANCE} cannot be used in {POSITION} of {FUNCTIONLIKE}

Cannot access internal class constant {CONST} defined at {FILE}:{LINE}

Cannot access internal {CLASS} defined at {FILE}:{LINE}

Cannot access internal constant {CONST} of namespace {NAMESPACE} defined at {FILE}:{LINE} from namespace {NAMESPACE}

Cannot access internal method {METHOD} of namespace {NAMESPACE} defined at {FILE}:{LINE} from namespace {NAMESPACE}

Cannot access internal property {PROPERTY} of namespace {NAMESPACE} defined at {FILE}:{LINE} from namespace {NAMESPACE}

Class {CLASS} inherits a class constant {CONST} declared at {FILE}:{LINE} marked as {COMMENT} in phpdoc but does not override it

Class {CLASS} inherits a method {METHOD} declared at {FILE}:{LINE} marked as {COMMENT} in phpdoc but does not override it

Class {CLASS} inherits a property {PROPERTY} declared at {FILE}:{LINE} marked as {COMMENT} in phpdoc but does not override it

Comment {STRING_LITERAL} refers to {TYPE} instead of \Closure - Assuming \Closure

Comment declares @method {METHOD} multiple times

Comment declares @property* ${PROPERTY} multiple times

Comment declares @param ${PARAMETER} multiple times

Saw an @inheritDoc annotation for method {METHOD}, but could not find an overridden method and it is not a magic method

Impossible phpdoc declaration that a class constant {CONST} has a type {TYPE} containing objects. This type is ignored during analysis.

Saw an @override annotation for class constant {CONST}, but could not find an overridden constant

Saw an @override annotation for method {METHOD}, but could not find an overridden method and it is not a magic method

Saw an @override annotation for property {PROPERTY}, but could not find an overridden property

Saw an @phan-assert annotation for ${PARAMETER}, but it was not found in the param list of {FUNCTIONLIKE}

Saw an @param annotation for ${PARAMETER}, but the param list of {FUNCTIONLIKE} is empty

Expected @param annotation for ${PARAMETER} to be before the @param annotation for ${PARAMETER}

Saw an @param annotation for ${PARAMETER}, but it was not found in the param list of {FUNCTIONLIKE}

Saw a line {COMMENT} with a type alias that could not be extracted

Saw a union type {TYPE} with more than 1 type in a location that does not support union types

Saw @var annotation for ${VARIABLE} but Phan expects the @param annotation to document the parameter with that name for {FUNCTION}

@phan-debug-var requested for variable ${VARIABLE} - it has union type {TYPE}

The phpdoc comment for {COMMENT} cannot occur on a {TYPE}

Saw misspelled annotation {COMMENT}. {SUGGESTION}

{FUNCTIONLIKE} can throw {CODE} of type {TYPE} here, but has no '@throws' declarations for that class

{FUNCTIONLIKE} can throw {TYPE} because it calls {FUNCTIONLIKE}, but has no '@throws' declarations for that class

{FUNCTIONLIKE} throws {CODE} of type {TYPE} here, but it only has declarations of '@throws {TYPE}'

{FUNCTIONLIKE} throws {TYPE} because it calls {FUNCTIONLIKE}, but it only has declarations of '@throws {TYPE}'

Saw attempt to use {TYPE} as a type alias for {TYPE} but internal types cannot be redefined.

Saw a type alias {TYPE} used outside of a comment - this will refer to a class name instead of {TYPE}

Saw unextractable annotation for comment '{COMMENT}'

Saw possibly unextractable annotation for a fragment of comment '{COMMENT}': after {TYPE}, did not see an element name (will guess based on comment order)

Saw unextractable annotation for a fragment of comment '{COMMENT}': '{COMMENT}'

Saw a token Phan may have failed to parse after '{COMMENT}': after {TYPE}, saw '{COMMENT}'

'{OPERATOR}' not in the 'loop' or 'switch' context.

Cannot '{OPERATOR}' {INDEX} levels.

"continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"?

Cannot use constant {CONST} as {CONST} because the name is already in use

Cannot use function {FUNCTION} as {FUNCTION} because the name is already in use

Cannot use {CLASSLIKE} as {CLASSLIKE} because the name is already in use

Constant expression contains invalid operations ({CODE})

%s

Invalid trait use: {DETAILS}

Cannot use temporary expression ({CODE} of type {TYPE}) in write context

Private constant is not allowed to be final

PHP warns about private method {METHOD} being final

Virtual property {PROPERTY} cannot have a default value - only properties with a set hook or backing storage can have defaults

Readonly property {PROPERTY} cannot have a set hook

Readonly property ${PROPERTY} must have a declared type

Saw a warning while parsing: {DETAILS}

Cannot use an empty list in the left hand side of an array destructuring operation

Syntax error: Case {CONST} of backed enum {CLASS} must have a value of type {TYPE}

Syntax error: Case {CONST} of unit enum {CLASS} must not have a value

Cannot mix keyed and unkeyed array entries in array destructuring assignments ({CODE})

Syntax error: Function {FUNCTIONLIKE} with return type {TYPE} must return a value (did you mean "{CODE}" instead of "{CODE}"?)

Syntax error: function {FUNCTIONLIKE} has return type {TYPE}, meaning it must not contain return statements (it should exit, throw, or run forever)

Syntax error: {TYPE} function {FUNCTIONLIKE} must not return a value (did you mean "{CODE}" instead of "{CODE}"?)