php文档对象已移动错误,由php中文文档一处错误引发的思考

PHP官方中文文档：

类常量这一节

说类常量不能为数学运算的结果。但我业务代码中这样写是完全可行的

class MyEvent

{

const READ = 1;

const WRITE = 1 << 1;

const ALL = self::READ | self::WRITE;

}

echo MyEvent::READ;

echo MyEvent::WRITE;

echo MyEvent::ALL;

我特意去看了源码，词法解析文件里面：

class_const_list:

class_const_list ',' class_const_decl { $$ = zend_ast_list_add($1, $3); }

| class_const_decl { $$ = zend_ast_create_list(1, ZEND_AST_CLASS_CONST_DECL, $1); }

class_const_decl:

identifier '=' expr backup_doc_comment { $$ = zend_ast_create(ZEND_AST_CONST_ELEM, $1, $3, ($4 ? zend_ast_create_zval_from_str($4) : NULL)); }

;

expr:

variable

{ $$ = $1; }

| T_LIST '(' array_pair_list ')' '=' expr

{ $3->attr = ZEND_ARRAY_SYNTAX_LIST; $$ = zend_ast_create(ZEND_AST_ASSIGN, $3, $6); }

| '[' array_pair_list ']' '=' expr

{ $2->attr = ZEND_ARRAY_SYNTAX_SHORT; $$ = zend_ast_create(ZEND_AST_ASSIGN, $2, $5); }

| variable '=' expr

{ $$ = zend_ast_create(ZEND_AST_ASSIGN, $1, $3); }

| variable '=' '&' variable

{ $$ = zend_ast_create(ZEND_AST_ASSIGN_REF, $1, $4); }

| T_CLONE expr { $$ = zend_ast_create(ZEND_AST_CLONE, $2); }

| variable T_PLUS_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_ADD, $1, $3); }

| variable T_MINUS_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_SUB, $1, $3); }

| variable T_MUL_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_MUL, $1, $3); }

| variable T_POW_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_POW, $1, $3); }

| variable T_DIV_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_DIV, $1, $3); }

| variable T_CONCAT_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_CONCAT, $1, $3); }

| variable T_MOD_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_MOD, $1, $3); }

| variable T_AND_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_BW_AND, $1, $3); }

| variable T_OR_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_BW_OR, $1, $3); }

| variable T_XOR_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_BW_XOR, $1, $3); }

| variable T_SL_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_SL, $1, $3); }

| variable T_SR_EQUAL expr

{ $$ = zend_ast_create_assign_op(ZEND_SR, $1, $3); }

| variable T_COALESCE_EQUAL expr

{ $$ = zend_ast_create(ZEND_AST_ASSIGN_COALESCE, $1, $3); }

| variable T_INC { $$ = zend_ast_create(ZEND_AST_POST_INC, $1); }

| T_INC variable { $$ = zend_ast_create(ZEND_AST_PRE_INC, $2); }

| variable T_DEC { $$ = zend_ast_create(ZEND_AST_POST_DEC, $1); }

| T_DEC variable { $$ = zend_ast_create(ZEND_AST_PRE_DEC, $2); }

| expr T_BOOLEAN_OR expr

{ $$ = zend_ast_create(ZEND_AST_OR, $1, $3); }

| expr T_BOOLEAN_AND expr

{ $$ = zend_ast_create(ZEND_AST_AND, $1, $3); }

| expr T_LOGICAL_OR expr

{ $$ = zend_ast_create(ZEND_AST_OR, $1, $3); }

| expr T_LOGICAL_AND expr

{ $$ = zend_ast_create(ZEND_AST_AND, $1, $3); }

| expr T_LOGICAL_XOR expr

{ $$ = zend_ast_create_binary_op(ZEND_BOOL_XOR, $1, $3); }

| expr '|' expr { $$ = zend_ast_create_binary_op(ZEND_BW_OR, $1, $3); }

| expr '&' expr { $$ = zend_ast_create_binary_op(ZEND_BW_AND, $1, $3); }

| expr '^' expr { $$ = zend_ast_create_binary_op(ZEND_BW_XOR, $1, $3); }

| expr '.' expr { $$ = zend_ast_create_binary_op(ZEND_CONCAT, $1, $3); }

| expr '+' expr { $$ = zend_ast_create_binary_op(ZEND_ADD, $1, $3); }

| expr '-' expr { $$ = zend_ast_create_binary_op(ZEND_SUB, $1, $3); }

| expr '*' expr { $$ = zend_ast_create_binary_op(ZEND_MUL, $1, $3); }

| expr T_POW expr { $$ = zend_ast_create_binary_op(ZEND_POW, $1, $3); }

| expr '/' expr { $$ = zend_ast_create_binary_op(ZEND_DIV, $1, $3); }

| expr '%' expr { $$ = zend_ast_create_binary_op(ZEND_MOD, $1, $3); }

| expr T_SL expr { $$ = zend_ast_create_binary_op(ZEND_SL, $1, $3); }

| expr T_SR expr { $$ = zend_ast_create_binary_op(ZEND_SR, $1, $3); }

| '+' expr %prec '~' { $$ = zend_ast_create(ZEND_AST_UNARY_PLUS, $2); }

| '-' expr %prec '~' { $$ = zend_ast_create(ZEND_AST_UNARY_MINUS, $2); }

| '!' expr { $$ = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, $2); }

| '~' expr { $$ = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BW_NOT, $2); }

| expr T_IS_IDENTICAL expr

{ $$ = zend_ast_create_binary_op(ZEND_IS_IDENTICAL, $1, $3); }

| expr T_IS_NOT_IDENTICAL expr

{ $$ = zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL, $1, $3); }

| expr T_IS_EQUAL expr

{ $$ = zend_ast_create_binary_op(ZEND_IS_EQUAL, $1, $3); }

| expr T_IS_NOT_EQUAL expr

{ $$ = zend_ast_create_binary_op(ZEND_IS_NOT_EQUAL, $1, $3); }

| expr '

{ $$ = zend_ast_create_binary_op(ZEND_IS_SMALLER, $1, $3); }

| expr T_IS_SMALLER_OR_EQUAL expr

{ $$ = zend_ast_create_binary_op(ZEND_IS_SMALLER_OR_EQUAL, $1, $3); }

| expr '>' expr

{ $$ = zend_ast_create(ZEND_AST_GREATER, $1, $3); }

| expr T_IS_GREATER_OR_EQUAL expr

{ $$ = zend_ast_create(ZEND_AST_GREATER_EQUAL, $1, $3); }

| expr T_SPACESHIP expr

{ $$ = zend_ast_create_binary_op(ZEND_SPACESHIP, $1, $3); }

| expr T_INSTANCEOF class_name_reference

{ $$ = zend_ast_create(ZEND_AST_INSTANCEOF, $1, $3); }

| '(' expr ')' {

$$ = $2;

if ($$->kind == ZEND_AST_CONDITIONAL) $$->attr = ZEND_PARENTHESIZED_CONDITIONAL;

}

| new_expr { $$ = $1; }

| expr '?' expr ':' expr

{ $$ = zend_ast_create(ZEND_AST_CONDITIONAL, $1, $3, $5); }

| expr '?' ':' expr

{ $$ = zend_ast_create(ZEND_AST_CONDITIONAL, $1, NULL, $4); }

| expr T_COALESCE expr

{ $$ = zend_ast_create(ZEND_AST_COALESCE, $1, $3); }

| internal_functions_in_yacc { $$ = $1; }

| T_INT_CAST expr { $$ = zend_ast_create_cast(IS_LONG, $2); }

| T_DOUBLE_CAST expr { $$ = zend_ast_create_cast(IS_DOUBLE, $2); }

| T_STRING_CAST expr { $$ = zend_ast_create_cast(IS_STRING, $2); }

| T_ARRAY_CAST expr { $$ = zend_ast_create_cast(IS_ARRAY, $2); }

| T_OBJECT_CAST expr { $$ = zend_ast_create_cast(IS_OBJECT, $2); }

| T_BOOL_CAST expr { $$ = zend_ast_create_cast(_IS_BOOL, $2); }

| T_UNSET_CAST expr { $$ = zend_ast_create_cast(IS_NULL, $2); }

| T_EXIT exit_expr { $$ = zend_ast_create(ZEND_AST_EXIT, $2); }

| '@' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $2); }

| scalar { $$ = $1; }

| '`' backticks_expr '`' { $$ = zend_ast_create(ZEND_AST_SHELL_EXEC, $2); }

| T_PRINT expr { $$ = zend_ast_create(ZEND_AST_PRINT, $2); }

| T_YIELD { $$ = zend_ast_create(ZEND_AST_YIELD, NULL, NULL); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; }

| T_YIELD expr { $$ = zend_ast_create(ZEND_AST_YIELD, $2, NULL); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; }

| T_YIELD expr T_DOUBLE_ARROW expr { $$ = zend_ast_create(ZEND_AST_YIELD, $4, $2); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; }

| T_YIELD_FROM expr { $$ = zend_ast_create(ZEND_AST_YIELD_FROM, $2); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; }

| inline_function { $$ = $1; }

| T_STATIC inline_function { $$ = $2; ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; }

;

很明显，只要符合expr的定义，在词法解析阶段就不会有问题。

class Test

{

const A = 1 + 1;

}

这样写是完全可行的，但有的人就会问了，为什么我这样写是不行的呢？

class Test

{

const A = Test2::$a + 1;

}

class Test2

{

public static $a = 1;

}

你不是说只要符合expr里的规则,词法解析阶段就没有问题吗？

const A = Test2::$a + 1;符合规则 expr '+' expr啊，为什么报错了。

别急，少年，先看看你的报错是啥？

PHP Fatal error: Constant expression contains invalid operations in xxxx

看到没有，是Fatal error，而不是Parse error，所以词法解析阶段是没有问题的，问题出在哪里？编译阶段出问题了，看以下代码：

void zend_compile_const_expr(zend_ast **ast_ptr) /* {{{ */

{

zend_ast *ast = *ast_ptr;

if (ast == NULL || ast->kind == ZEND_AST_ZVAL) {

return;

}

if (!zend_is_allowed_in_const_expr(ast->kind)) {

zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");

}

switch (ast->kind) {

case ZEND_AST_CLASS_CONST:

zend_compile_const_expr_class_const(ast_ptr);

break;

case ZEND_AST_CLASS_NAME:

zend_compile_const_expr_class_name(ast_ptr);

break;

case ZEND_AST_CONST:

zend_compile_const_expr_const(ast_ptr);

break;

case ZEND_AST_MAGIC_CONST:

zend_compile_const_expr_magic_const(ast_ptr);

break;

default:

zend_ast_apply(ast, zend_compile_const_expr);

break;

}

}

看到触发这条错误信息的判断条件了吗？zend_is_allowed_in_const_expr(ast->kind)，如果抽象语法树的类型不在允许范围内，就算符合词法解析规则，依然会报错。

看看zend_is_allowed_in_const_expr的实现.

zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */

{

return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP

|| kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL

|| kind == ZEND_AST_AND || kind == ZEND_AST_OR

|| kind == ZEND_AST_UNARY_OP

|| kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS

|| kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM

|| kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM

|| kind == ZEND_AST_UNPACK

|| kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST

|| kind == ZEND_AST_CLASS_NAME

|| kind == ZEND_AST_MAGIC_CONST || kind == ZEND_AST_COALESCE;

}

清楚了，刚才的例子之所以通不过，是因为类的静态变量ast->kind为ZEND_AST_STATIC_PROP，并不在上面范围里面，所以通不过。如果你把Test2中的静态变量换成常量，编译就可以通过，因为ZEND_AST_CLASS_CONST是在允许范围内的。

所以官方中文文档中的这句话应该改为:

常量的值必须是一个常量表达式，不能是变量、类属性或函数调用