class A:
   _ref: Self

class B(A):
   def func(self):
      self._ref # should be inferred as `B`

from typing import Self, TypeGuard, Protocol
from typing_extensions import reveal_type

class Node:
    _original: Self | None
    _x: int
    
    def __init__(self, x: int) -> None:
        self._original = None
        self._x = x
    
    @property
    def isClone(self) -> bool:
        return self._original is not None
    
    @property
    def x(self) -> int:
        if self._original is not None:
            return self._original.x
        return self._x
    
    def clone(self: Self) -> Self:
        cls = type(self)
        cloned = cls.__new__(cls)
        cloned._original = self
        return cloned


class Node2D(Node):
    _y: int
    
    def __init__(self, x: int, y: int) -> None:
        super().__init__(x)
        self._y = y
    
    @property
    def y(self) -> int:
        if self._original is not None:
            reveal_type(self._original)
            return self._original.y
        return self._y


n2 = Node2D(10, 20)
n2c = n2.clone()

reveal_type(n2c)
reveal_type(n2c._original)