Compiler Warnings¶

The compiler raises warnings when it finds situations where the code can be improved, or a potential error can be avoided.

Warnings can be enabled via command line parameters, or can be added to the config.json to enable or disable them more permanently.

You can enable warnings by passing their name prefixed by -w:

zephir -wunused-variable -wnonexistent-function

Warnings can be disabled by passing their name prefixed by -W:

zephir -Wunused-variable -Wnonexistent-function

The following warnings are supported:

unused-variable¶

Raised when a variable is declared, but it is not used within a method. This warning is enabled by default.

public function some()
{
    var e; // declared but not used

    return false;
}

unused-variable-external¶

Raised when a parameter is declared, but it is not used within a method.

public function sum(a, b, c) // c is not used
{
    return a + b;
}

possible-wrong-parameter-undefined¶

Raised when a method is called with a wrong type for a parameter:

public function some()
{
    return this->sum("a string", "another");  // wrong parameters passed
}

public function sum(int a, int b)
{
    return a + b;
}

nonexistent-function¶

Raised when a function is called that does not exist at compile time:

public function some()
{
    someFunction(); // someFunction does not exist
}

nonexistent-class¶

Raised when a class is used that does not exist at compile time:

public function some()
{
    var a;

    let a = new \MyClass(); // MyClass does not exist
}

non-valid-isset¶

Raised when the compiler detects that an 'isset' operation is being made on a non-array or -object value:

public function some()
{
    var b = 1.2;

    return isset b[0]; // variable integer 'b' used as array
}

non-array-update¶

Raised when the compiler detects that an array update operation is being made on a non-array value:

public function some()
{
    var b = 1.2;
    let b[0] = true; // variable 'b' cannot be used as array
}

non-valid-objectupdate¶

Raised when the compiler detects that an object update operation is being made on a non-object value:

public function some()
{
    var b = 1.2;
    let b->name = true; // variable 'b' cannot be used as object
}

non-valid-fetch¶

Raised when the compiler detects that a 'fetch' operation is being made on a non-array or -object value:

variable integer 'b' used as array¶

public function some()
{
    var b = 1.2, a;
    fetch a, b[0];
}

invalid-array-index¶

Raised when the compiler detects that an invalid array index is used:

public function some(var a)
{
    var b = [];
    let a[b] = true;
}

non-array-append¶

Raised when the compiler detects that an element is being appended to a non-array variable:

public function some()
{
    var b = false;
    let b[] = "some value";
}