Consistency rules

This document details the rules available in the Consistency category.

Rule	Code
Ambiguous Constant Access	ambiguous-constant-access
Ambiguous Function Call	ambiguous-function-call
Array Style	array-style
Assertion Style	assertion-style
Block Statement	block-statement
Braced String Interpolation	braced-string-interpolation
Class Name	class-name
Constant Name	constant-name
Enum Name	enum-name
File Name	file-name
Function Name	function-name
Interface Name	interface-name
Lowercase Keyword	lowercase-keyword
Lowercase Type Hint	lowercase-type-hint
Method Name	method-name
No Alias Function	no-alias-function
No Alternative Syntax	no-alternative-syntax
No Fully Qualified Global Class-Like	no-fully-qualified-global-class-like
No Fully Qualified Global Constant	no-fully-qualified-global-constant
No Fully Qualified Global Function	no-fully-qualified-global-function
No Hash Comment	no-hash-comment
No Php Tag Terminator	no-php-tag-terminator
No Trailing Space	no-trailing-space
Property Name	property-name
String Style	string-style
Trait Name	trait-name
Variable Name	variable-name

ambiguous-constant-access

Enforces that all constant references made from within a namespace are explicit.

When an unqualified constant like PHP_VERSION is referenced from within a namespace, PHP performs a runtime fallback check (current namespace -> global namespace). This ambiguity can lead to unexpected behavior if a constant with the same name is later defined in the namespace.

Making references explicit improves readability and prevents bugs.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"

Examples

Correct code

<?php

namespace App;

use const PHP_VERSION;

// OK: Explicitly imported
$version1 = PHP_VERSION;

// OK: Explicitly global
$version2 = \PHP_VERSION;

Incorrect code

<?php

namespace App;

// Ambiguous: could be App\PHP_VERSION or \PHP_VERSION
$version = PHP_VERSION;

ambiguous-function-call

Enforces that all function calls made from within a namespace are explicit.

When an unqualified function like strlen() is called from within a namespace, PHP performs a runtime fallback check (current namespace -> global namespace). This ambiguity prevents PHP from performing powerful compile-time optimizations, such as replacing a call to strlen() with the highly efficient STRLEN opcode.

Making calls explicit improves readability, prevents bugs, and allows for significant performance gains in some cases.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"

Examples

Correct code

<?php

namespace App;

use function strlen;

// OK: Explicitly imported
$length1 = strlen("hello");

// OK: Explicitly global
$length2 = \strlen("hello");

// OK: Explicitly namespaced
$value = namespace\my_function();

Incorrect code

<?php

namespace App;

// Ambiguous: could be App\strlen or \strlen
$length = strlen("hello");

array-style

Suggests using the short array style [..] instead of the long array style array(..), or vice versa, depending on the configuration. The short array style is more concise and is the preferred way to define arrays in PHP.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"
style	string	"short"

Examples

Correct code

<?php

// By default, `style` is 'short', so this snippet is valid:
$arr = [1, 2, 3];

Incorrect code

<?php

// By default, 'short' is enforced, so array(...) triggers a warning:
$arr = array(1, 2, 3);

assertion-style

Enforces a consistent style for PHPUnit assertion calls within test methods.

Maintaining a consistent style (e.g., always using static:: or $this->) improves code readability and helps enforce team-wide coding standards in test suites. This rule can be configured to enforce the preferred style.

Requirements

• Integration: PHPUnit

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"warning"
style	string	"static"

Examples

Correct code

<?php
// configured style: "static"
final class SomeTest extends TestCase
{
    public function testSomething(): void
    {
        static::assertTrue(true);
    }
}

Incorrect code

<?php
// configured style: "static"
final class SomeTest extends TestCase
{
    public function testSomething(): void
    {
        $this->assertTrue(true); // Incorrect style
        self::assertFalse(false); // Incorrect style
    }
}

block-statement

Enforces that if, else, for, foreach, while, do-while statements always use a block statement body ({ ... }) even if they contain only a single statement.

This improves readability and prevents potential errors when adding new statements.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"

Examples

Correct code

<?php

if (true) {
    echo "Hello";
}

for ($i = 0; $i < 10; $i++) {
    echo $i;
}

Incorrect code

<?php

if (true)
    echo "Hello";

for ($i = 0; $i < 10; $i++)
    echo $i;

braced-string-interpolation

Enforces the use of curly braces around variables within string interpolation.

Using curly braces ({$variable}) within interpolated strings ensures clarity and avoids potential ambiguity, especially when variables are followed by alphanumeric characters. This rule promotes consistent and predictable code.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"

Examples

Correct code

<?php

$a = "Hello, {$name}!";
$b = "Hello, {$name}!";
$c = "Hello, {$$name}!";
$d = "Hello, {${$object->getMethod()}}!";

Incorrect code

<?php

$a = "Hello, $name!";
$b = "Hello, ${name}!";
$c = "Hello, ${$name}!";
$d = "Hello, ${$object->getMethod()}!";

class-name

Detects class declarations that do not follow class naming convention.

Class names should be in class case, also known as PascalCase.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"
psr	boolean	false

Examples

Correct code

<?php

class MyClass {}

Incorrect code

<?php

class my_class {}

class myClass {}

class MY_CLASS {}

constant-name

Detects constant declarations that do not follow constant naming convention.

Constant names should be in constant case, also known as UPPER_SNAKE_CASE.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"

Examples

Correct code

<?php

const MY_CONSTANT = 42;

class MyClass {
    public const int MY_CONSTANT = 42;
}

Incorrect code

<?php

const myConstant = 42;
const my_constant = 42;
const My_Constant = 42;

class MyClass {
    public const int myConstant = 42;
    public const int my_constant = 42;
    public const int My_Constant = 42;
}

enum-name

Detects enum declarations that do not follow class naming convention.

Enum names should be in class case, also known as PascalCase.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"

Examples

Correct code

<?php

enum MyEnum {}

Incorrect code

<?php

enum my_enum {}
enum myEnum {}
enum MY_ENUM {}

file-name

Ensures that a file containing a single class-like definition is named after that definition.

For example, a file containing class Foo must be named Foo.php. Optionally, this rule can also check functions: a file containing a single function foo must be named foo.php.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"warning"
check-functions	boolean	false

Examples

Correct code

<?php
// File: test.php

namespace App;

class test
{
}

Incorrect code

<?php
// File: test.php

namespace App;

class Foo
{
}

function-name

Detects function declarations that do not follow camel or snake naming convention.

Function names should be in camel case or snake case, depending on the configuration.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"
camel	boolean	false
either	boolean	false

Examples

Correct code

<?php

function my_function() {}

Incorrect code

<?php

function MyFunction() {}

function My_Function() {}

interface-name

Detects interface declarations that do not follow class naming convention.

Interface names should be in class case and suffixed with Interface, depending on the configuration.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"
psr	boolean	false

Examples

Correct code

<?php

interface MyInterface {}

Incorrect code

<?php

interface myInterface {}
interface my_interface {}
interface MY_INTERFACE {}

lowercase-keyword

Enforces that PHP keywords (like if, else, return, function, etc.) be written in lowercase. Using uppercase or mixed case is discouraged for consistency and readability.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"

Examples

Correct code

<?php

if (true) {
    echo "All keywords in lowercase";
} else {
    return;
}

Incorrect code

<?PHP

IF (TRUE) {
    ECHO "Keywords not in lowercase";
} ELSE {
    RETURN;
}

lowercase-type-hint

Enforces that PHP type hints (like void, bool, int, float, etc.) be written in lowercase. Using uppercase or mixed case is discouraged for consistency and readability.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"

Examples

Correct code

<?php

function example(int $param): void {
    return;
}

Incorrect code

<?php

function example(Int $param): VOID {
    return;
}

method-name

Detects method declarations that do not follow the configured naming convention.

By default, method names should be in camelCase. Magic methods (prefixed with __) are always excluded.

The use-snake-case-for-tests option enforces snake_case for test methods (names starting with test), which is a common convention in PHPUnit.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"
camel	boolean	true
either	boolean	false
use-snake-case-for-tests	boolean	false

Examples

Correct code

<?php

class Foo
{
    public function getName(): string {}
    public function setName(string $name): void {}
}

Incorrect code

<?php

class Foo
{
    public function GetName(): string {}
    public function set_name(string $name): void {}
}

no-alias-function

Detects usage of function aliases (e.g., diskfreespace instead of disk_free_space) and suggests calling the canonical (original) function name instead. This is primarily for consistency and clarity.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"

Examples

Correct code

<?php

// 'disk_free_space' is the proper name instead of 'diskfreespace'
$freeSpace = disk_free_space("/");

Incorrect code

<?php

// 'diskfreespace' is an alias for 'disk_free_space'
$freeSpace = diskfreespace("/");

no-alternative-syntax

Detects the use of alternative syntax for control structures (endif, endwhile, endfor, endforeach, endswitch).

The brace-style syntax is preferred for consistency with the rest of the codebase and is the convention used by the Symfony coding standards.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"warning"

Examples

Correct code

<?php

if ($condition) {
    echo 'yes';
}

Incorrect code

<?php

if ($condition):
    echo 'yes';
endif;

no-fully-qualified-global-class-like

Disallows fully-qualified class-like references within a namespace.

Instead of using the backslash prefix (e.g., new \DateTime() or \Exception in a type hint), prefer an explicit use import statement. This improves readability and keeps imports centralized at the top of the file.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"

Examples

Correct code

<?php

namespace App;

use DateTime;
use Exception;

$dt = new DateTime();

function foo(DateTime $dt): Exception {}

Incorrect code

<?php

namespace App;

$dt = new \DateTime();

function foo(\DateTime $dt): \Exception {}

no-fully-qualified-global-constant

Disallows fully-qualified references to global constants within a namespace.

Instead of using the backslash prefix (e.g., \PHP_VERSION), prefer an explicit use const import statement. This improves readability and keeps imports centralized at the top of the file.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"

Examples

Correct code

<?php

namespace App;

use const PHP_VERSION;

$version = PHP_VERSION;

Incorrect code

<?php

namespace App;

$version = \PHP_VERSION;

no-fully-qualified-global-function

Disallows fully-qualified references to global functions within a namespace.

Instead of using the backslash prefix (e.g., \strlen()), prefer an explicit use function import statement. This improves readability and keeps imports centralized at the top of the file.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"

Examples

Correct code

<?php

namespace App;

use function strlen;

$length = strlen("hello");

Incorrect code

<?php

namespace App;

$length = \strlen("hello");

no-hash-comment

Detects shell-style comments ('#') in PHP code. Double slash comments ('//') are preferred in PHP, as they are more consistent with the language's syntax and are easier to read.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"warning"

Examples

Correct code

<?php

// This is a good comment.

Incorrect code

<?php

# This is a shell-style comment.

no-php-tag-terminator

Discourages the use of ?><?php as a statement terminator. Recommends using a semicolon (;) instead for clarity and consistency.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"

Examples

Correct code

<?php

echo "Hello World";

Incorrect code

<?php

echo "Hello World" ?><?php

no-trailing-space

Detects trailing whitespace at the end of comments. Trailing whitespace can cause unnecessary diffs and formatting issues, so it is recommended to remove it.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"note"

Examples

Correct code

<?php

// This is a good comment.

Incorrect code

<?php

// This is a comment with trailing whitespace.

property-name

Detects class property declarations that do not follow camel or snake naming convention.

Property names should be in camel case or snake case, depending on the configuration.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"
camel	boolean	true
either	boolean	false

Examples

Correct code

<?php

final class Foo {
    public string $myProperty;

    public function __construct(
        public int $myPromotedProperty,
    ) {}
}

Incorrect code

<?php

final class Foo {
    public string $My_Property;

    public function __construct(
        public int $My_Promoted_Property,
    ) {}
}

string-style

Enforces a consistent string style: either prefer string interpolation over concatenation, or prefer concatenation over interpolation.

With style: interpolation (default), flags concatenation like "foo" . $a . "bar" and suggests "foo{$a}bar" instead.

With style: concatenation, flags interpolation like "foo{$a}bar" and suggests "foo" . $a . "bar" instead.

Only simple, interpolable expressions are considered: variables, property accesses, array accesses, and method calls. Concatenation involving function calls, static access, or complex expressions is never flagged.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"note"
style	string	"interpolation"

Examples

Correct code

<?php

// With the default `style: interpolation`:
$a = "Hello, {$name}!";
$b = "value: {$obj->name}";

// Complex expressions stay as concatenation (never flagged):
$c = "result: " . strtolower($input);
$d = "class: " . Foo::class;

Incorrect code

<?php

// With the default `style: interpolation`:
$a = "Hello, " . $name . "!";
$b = "value: " . $obj->name;

trait-name

Detects trait declarations that do not follow class naming convention. Trait names should be in class case and suffixed with Trait, depending on the configuration.

Configuration

Option	Type	Default
enabled	boolean	true
level	string	"help"
psr	boolean	false

Examples

Correct code

<?php

trait MyTrait {}

Incorrect code

<?php

trait myTrait {}
trait my_trait {}
trait MY_TRAIT {}

variable-name

Detects variable declarations that do not follow camel or snake naming convention.

Variable names should be in camel case or snake case, depending on the configuration.

Configuration

Option	Type	Default
enabled	boolean	false
level	string	"help"
camel	boolean	false
either	boolean	true
check-parameters	boolean	true

Examples

Correct code

<?php

$my_variable = 1;

function foo($my_param) {}

Incorrect code

<?php

$MyVariable = 1;
$My_Variable = 2;

function foo($MyParam) {}