Understanding the scope resolution operator's definition in PHP language

Question

On the php manual they define the scope resolution operator as following:

The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden properties or methods of a class.

My understanding is since we cannot assess static properties, class constants and static methods with $this, we need ::. I don't see why :: is allowed to assess non-static functions from inside the class. It could be said that a child class may want to assess the methods defined in the parent class with parent::baseClassMethod(), but then it might want to assess the properties defined in the parent class as well, but the :: can't assess the properties. It could be said that parent class's properties are inherited, so we can assess them simply with $this->prop, but the same is true with methods. We use :: for methods only when they are overriden in child class. Similarily we'd need :: to assess overriden properties in the child class. Contrary to the php manual definition, if you try to assess the overriden properties with ::, it throws error.

To illustrate my point, I have the following sample PHP code:

error_reporting(E_ALL);
class myClass {
    private $prop = 786; 
    public $prop2 = 123;

    public function changeType($var, $type){
        settype($var, $type);
        echo "function assessed through self";
    }
    public function display_prop(){
        self::changeType(1, "string"); //why does this not throw error for non static function?
        var_dump(self::$prop); //throws error; can't assess properties with self as expected.
    }    
}

class childCLass extends myClass {
    public $prop2 = "new"; //overriden property.

    public function display_prop(){ //overriden method.
        echo "I do different things from the base class". "</br>";      
    }
    public function dsiplay_overriden(){
        echo parent::$prop2; //Why can't assess overriden properties, as suggested in the definition?
    }
}

$obj = new myClass;
$obj->display_prop(); 

$obj2 = new childCLass;
$obj2->display_prop();
$obj2->dsiplay_overriden();

childClass::display_prop(); //This throws error as expected because non-static method.

To Sum it up I have two specific questions mainly:

1. Why can't we access overridden properties with :: as defined in the definition?
2. Why can we access non-static functions inside a class with ::, contrary to the definition?

---

^{P.S: A similar question has been asked on stackoverflow. No satisfactory answer exists, plus I am looking for a conceptual and insightful answer which is more appropriate at programmers.stackexchange.}

Answer 1

I'll give it a try :)

Methods and static properties exist only once in memory, non-static properties of an class-instance (object) exist per instance, eg. have their own space in memory.

1. You cannot "override" a public or protected property of an class. Instead, the declaration of the same property-name in an derived class will "overshadow" the base class declaration. Effectively, they share the same place in memory, making them "the same", just as if you declare a variable of the same name twice in the global namespace. Reason for this is the inheritance, you inherit all public and protected properties of a base class. Private properties are not inherited, an instance of a derived class will have 2 separate memory areas for a property of the same name. See Example A below.

2. Scope resolution does not prohibit the non-static access. The first sentence in PHP documentation even says so: The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden properties or methods of a class. In fact, it resolves the scope, eg. it determines, if it has to access static (shared) or local memory.

The special variable $this can only access the local memory, it stands for the "reference to the current instance" and is automatically available in non-static class methods, but NOT in static methods! Historically it comes from C++ (keyword "this"), where class methods are organized in a map of function-pointers for all the class methods, so-called v-table. All non-static class methods receive an additional (invisible) last parameter named "this" and a call to non-static methods is resolved at runtime (in contrast to static methods which are resolved at compile time).

Now, when you create an instance of a class, like $obj = new Foo(); two things will happen - memory is allocated for the object and the constructor of the class is being called. Constructors cannot be declared static, simply because they are responsible to initialize the memory properly. As non-static method, they'll receive $this automatically.

So, when a non-static method is called, like $obj->method(), the runtime environment will recognize, the $obj is an class instance. It checks the v-table of the class to find the method (which is nothing else than a regular function, but with the extra parameter $this) and calls it, passing $obj as $this, pseudo code $vtable['Foo']['method']($obj). Inside the class method, you have then access to $this.

Lastly, calling a non-static method statically, respectively calling a static method in non-static fashion: Actually you could do both, if you keep following in mind.

Non-static method, called with Foo::bar();: $this will be null!

Static method, called with $obj->bar();: Cannot reference $this in the method, as it won't be passed automatically!

Example A (Inheritance of public, protected and private members & static/non-static method access):

class A {
    public $x = 'a_x';
    protected $y = 'a_y';
    private $z = 'a_z';
}
class B extends A {
    public $x = 'b_x';
    protected $y = 'b_y';
    private $z = 'b_z';

    public static function foo() {
        echo 'foo' . PHP_EOL;
    }
    public function bar() {
        echo 'bar' . PHP_EOL;
    }
}
$a = new A();
$b = new B();

var_dump($a, $b);
$b->foo();
B::bar();

Output:

object(A)#1 (3) {
  ["x"]=>
  string(3) "a_x"
  ["y":protected]=>
  string(3) "a_y"
  ["z":"A":private]=>
  string(3) "a_z"
}
object(B)#2 (4) {
  ["x"]=>
  string(3) "b_x"
  ["y":protected]=>
  string(3) "b_y"
  ["z":"B":private]=>
  string(3) "b_z"
  ["z":"A":private]=>
  string(3) "a_z"
}
foo
bar

As you can see, there is no problem calling a static function with $this->foo() nor a problem calling a non-static function with B::bar(). However, if you try to access $this in these scenarios, you'll get Fatal errors...