[WIP] Support 'static const CONST_NAME = expr;'

[TysonAndre]

Currently, this is limited to the global scope.
This can be thought of as similar to C:
the static const can only be seen within the namespace block scope.

Differences from global constants:

• A name can only be declared once per namespace block.

• The name can only be used by the following statements in the namespace block.

• This can support any expression define() would accept
  (function calls, $variable, properties, etc.).

• This is eagerly evaluated when the expression might be dynamic.

  This is deliberate, and meant to make accidental infinite recursion
  (and unexpected side effects of fetching a constant for the first time)
  less likely.

  This may throw in the future.

• The value from the first successful declaration is used and permanently stored.

Similarities to global constants:

• 'static const' rejects the same types
  (references, objects, and reference cycles.)
• 'static const' cannot be modified once declared

The current implementation allows code such as this:

static const LOCAL_X = "Local $x";
class Example {
    const X = LOCAL_X;
}

Which is shorthand for:

if (!defined('UNIQUE_NAME_FOR_LOCAL_X')) {
    define('UNIQUE_NAME_FOR_LOCAL_X', "Local $x");
}
class Example {
    const X = \LOCAL_NAME_FOR_LOCAL_X;
}

Unfinished work:

• Work out what to do if the expression throws an exception/error.
  (Fatal error? Leave as is?)
• Decide what this should do if the define() call fails.
  (Fatal error? Throw a regular Error?)
• (Optional) opcache optimizations such as evaluating functions at compile time.

---

• Fix eval - account for it being possible when generating unique constant names based on the current file.

• Fix loading the same file path with different contents - if require is called twice, so the file name isn't unique (For files, a hash of the file contents would make more sense and work better with opcache)

  php > eval('echo json_encode(__FILE__) . "\n";');
  "php shell code(1) : eval()'d code"
  

• Benchmark static const vs static variable for repeated calls

• Undo limitation to top-level statements (block scope is a TODO). Add a variant of DECLARE_CONST that ignores the constant already existing.

• Look into how to allow opcache to optimize static const DEBUG = false; if (DEBUG) {} with dead code detection

[TysonAndre]

Note to self: It might be worth looking into whether this improves performance, once I implement block scoping (e.g. for functions). Code such as the following wouldn't have to create a reference to a static variable and dereference it.

<?php
function fib($n) : int {
    return $n >= 1 ? fib($n - 1) + fib($n - 2) : $n;
}
function test1() : int {
    static $x = null;
    return $x ??= fib(5);
}
function test2() : int {
    if (!defined('SOME_UNIQUE_CONST')) {
        define('SOME_UNIQUE_CONST', fib(5));
    }
    return SOME_UNIQUE_CONST;
}