Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:123349
Feedback-ID: id5114917:Fastmail
Content-Type: multipart/alternative;
 boundary="------------82O05yHVXD8dZ7f1lLmwYhWY"
Message-ID: <69669f3c-8e9e-4f27-a171-6c341c1d67f7@rwec.co.uk>
Date: Sat, 18 May 2024 16:14:48 +0100
Precedence: bulk
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PHP-DEV] [Discussion] "Internal" attribute and warning
To: internals@lists.php.net
References: <CAPzBOBMpOztgNQx35ZnP4c5ZHV-Ax1ETH0=YMzVT9Hq9cdyyDQ@mail.gmail.com>
Content-Language: en-GB
In-Reply-To: <CAPzBOBMpOztgNQx35ZnP4c5ZHV-Ax1ETH0=YMzVT9Hq9cdyyDQ@mail.gmail.com>
From: imsop.php@rwec.co.uk ("Rowan Tommins [IMSoP]")

This is a multi-part message in MIME format.
--------------82O05yHVXD8dZ7f1lLmwYhWY
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

On 18/05/2024 15:00, Robert Landers wrote:
> I've been thinking about having an "internal" attribute that will emit
> a warning if called from outside it's left-most namespace.


I like the general idea, but I don't think limiting to "left-most 
namespace" is the best semantics.

It's very common for the top-level namespace to represent a vendor, and 
the *second* level to be the specific package, e.g. Doctrine\DBAL vs 
Doctrine\ORM. You've even used that in your example - I presume you've 
made a typo, and meant both examples to be calling PackageA not 
PackageB. In other cases, there are more levels - e.g. Composer package 
"doctrine/mongodb-odm" has root namespace "Doctrine\ODM\MongoDB".

Possibly the attribute would need some argument to specify its 
granularity, e.g.  #[Internal('\MyCompany\PackageA')], 
#[Internal('\Doctrine\ODM\MongoDB')], but that would be annoying to 
write each time.

This is another case where PHP suffers from its lack of a separate 
concept of "package" or "module" to scope things to.


My second concern is how to implement this efficiently. The check can't 
happen at compile-time, because we don't know the definition of 
SomeOtherNamespace\Foo; so the check would need to be at run-time when 
the method/function is called. But at run-time, namespaces have very 
little existence - they really are just part of the names of functions, 
classes, and constants.

So when calling a marked function, we would have to look up the name of 
the calling function or the class name of the calling method, and then 
do a string comparison against the namespace constraint. Maybe that 
would be easy and fast, I don't know.

Regards,

-- 
Rowan Tommins
[IMSoP]

--------------82O05yHVXD8dZ7f1lLmwYhWY
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 8bit

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <div class="moz-cite-prefix">On 18/05/2024 15:00, Robert Landers
      wrote:<br>
    </div>
    <blockquote type="cite"
cite="mid:CAPzBOBMpOztgNQx35ZnP4c5ZHV-Ax1ETH0=YMzVT9Hq9cdyyDQ@mail.gmail.com">
      <pre>I've been thinking about having an "internal" attribute that will emit
a warning if called from outside it's left-most namespace.</pre>
    </blockquote>
    <p><br>
    </p>
    <p>I like the general idea, but I don't think limiting to "left-most
      namespace" is the best semantics. </p>
    <p>It's very common for the top-level namespace to represent a
      vendor, and the *second* level to be the specific package, e.g.
      Doctrine\DBAL vs Doctrine\ORM. You've even used that in your
      example - I presume you've made a typo, and meant both examples to
      be calling PackageA not PackageB. In other cases, there are more
      levels - e.g. Composer package "doctrine/mongodb-odm" has root
      namespace "Doctrine\ODM\MongoDB".<br>
    </p>
    <p>Possibly the attribute would need some argument to specify its
      granularity, e.g.  #[Internal('\MyCompany\PackageA')],
      #[Internal('\Doctrine\ODM\MongoDB')], but that would be annoying
      to write each time.<br>
    </p>
    <p>This is another case where PHP suffers from its lack of a
      separate concept of "package" or "module" to scope things to. </p>
    <p><br>
    </p>
    <p>My second concern is how to implement this efficiently. The check
      can't happen at compile-time, because we don't know the definition
      of SomeOtherNamespace\Foo; so the check would need to be at
      run-time when the method/function is called. But at run-time,
      namespaces have very little existence - they really are just part
      of the names of functions, classes, and constants.<br>
    </p>
    <p>So when calling a marked function, we would have to look up the
      name of the calling function or the class name of the calling
      method, and then do a string comparison against the namespace
      constraint. Maybe that would be easy and fast, I don't know.</p>
    <p>Regards,<br>
    </p>
    <pre class="moz-signature" cols="72">-- 
Rowan Tommins
[IMSoP]</pre>
  </body>
</html>

--------------82O05yHVXD8dZ7f1lLmwYhWY--