hi Dmitry,

What's your thoughts on this one? Someone asked me about it and we found this old bug.

A workaround is to implement __isset but that makes little sense (isset != empty) and is counter intuitive.

Simple test script to trigger the bug:

<?php

class Foo {
	public $vars;

	function Foo() {
		$this->vars['bar'] = 1;
	}

	function __get($var) {
		return $this->vars[$var];
	}
}

$foo = new Foo;

var_dump(empty($foo->bar));
$baz = $foo->bar;
var_dump(empty($baz));

Expected result:
----------------
bool(false) bool(false) 

Actual result:
--------------
bool(true) bool(false)

Let document the __isset requirements better, when one relies on empty.

Fixed the overloading property vs language construct issue in the documentation.

This feature request is still valid, so moving it to be one instead of a documentation issue

I made the start of a patch for this, but there is some issues that would need to 
be worked out with has_property calls, it seems oddly interfaced with by the 
various callers.

http://pastebin.com/d5gQycDB

The documentation states:

"empty() only checks variables as anything else will result in a parse error"

if 'everything else' is a __get() returning an array with a value in it, it returns TRUE,

Ubuntu 10.04 PHP 5.3.2-1ubuntu4.17

reproducable with:

class Test {
        private $test;
 
        function __construct($test)
        {
                $this->test = $test;
        }
 
        public function __get($key)
        {
                return $this->$key;
        }
 
        public function getTest()
        {
                return $this->test;
        }
}
 
$test = new Test('test');
 
if (!empty($test->test)) {
        echo $test->test;
} else {
        echo 'empty';
}
 
echo '<br />';
echo $test->test;
echo '<br />';
echo $test->getTest();

This functionality is already supported, you simply need to implement both __isset() and __get(). empty($foo->bar) is semantically identical to !isset($foo->bar) || !$foo->bar. As such, a meaningful handling of empty() requires both of these handlers to be implemented.