New Feature: Fully qualified class name resolution as scalar with class keyword View as Markdown

I used to implement public static function getClass() { returnget_called_class(); }, so I really like this one, makes it also easier for
IDEs when refactoring code :)

I was wondering about class A { const CLASS = 'hello'; } but that would
cause an unexpected T_CLASS, so I guess there's no conflicts...

Marco Pivetta

http://twitter.com/Ocramius

http://marco-pivetta.com

Hi all,

There are many different use cases were in code we expect classes names as
arguments to functions as fully qualified names. We do this in ZF a lot
with our Service Location and DI components, but also with our code
reflection API, etc. A more interesting use case I would like to call out
is with PHPUnit, for example in a test, you might find this:

$mock = $this->getMock('A\Namespaced**ClassName');

This becomes cumbersome when you are dealing with lots of strings about
lots of class names. This is also an area where, currently, namespace
declaration and use statements offer no real support.

The patch located here:

https://github.com/ralphschindler/php-src/commit/
02210d51851a96d723fbedcfc64cde**9f9ae2b22ahttps://github.com/ralphschindler/php-src/commit/02210d51851a96d723fbedcfc64cde9f9ae2b22a

... implements the ability for a developer to leverage the file's
namespace declaration and use statements to be able to produce a scalar
(string) of the class name that can be then used, for example, as an
argument to a function elsewhere.

This overloads the "class" keyword, and by virtue of the existing usage of
"class" this feature is completely backwards compatible. All existing
tests pass. For example, the above PHPUnit snipped would become:

use A\Namespaced\ClassName;
$mock = $this->getMock(ClassName::**class);

Another example with reflection:

use SomeOther\FullyNamespaced**ClassElsewhere as CE;
$r = new ReflectionClass(CE::class);

More examples from the test file:

namespace Foo\Bar {
class Baz {}
var_dump(Moo::CLASS); // "Foo\Bar\Moo"
}

namespace {
use Bee\Bop as Moo,
Foo\Bar\Baz;

var_dump(Baz::class); // "Foo\Bar\Baz"
var_dump(Boo::class); // "Boo"
var_dump(Moo::CLASS); // "Bee\Bop"
var_dump(\Moo::Class); // "Moo"

$class = Baz::class; // assign class as scalar to var
$x = new $class;
var_dump($x); object(Foo\Bar\Baz)#1 (0) {}
}

What do you guys think?

-ralph

2012/4/14 Ralph Schindler ralph@ralphschindler.com:

Hi all,

There are many different use cases were in code we expect classes names as
arguments to functions as fully qualified names.  We do this in ZF a lot
with our Service Location and DI components, but also with our code
reflection API, etc.  A more interesting use case I would like to call out
is with PHPUnit, for example in a test, you might find this:

 $mock = $this->getMock('A\Namespaced\ClassName');

This becomes cumbersome when you are dealing with lots of strings about lots
of class names.  This is also an area where, currently, namespace
declaration and use statements offer no real support.

The patch located here:

https://github.com/ralphschindler/php-src/commit/02210d51851a96d723fbedcfc64cde9f9ae2b22a

... implements the ability for a developer to leverage the file's namespace
declaration and use statements to be able to produce a scalar (string) of
the class name that can be then used, for example, as an argument to a
function elsewhere.

This overloads the "class" keyword, and by virtue of the existing usage of
"class" this feature is completely backwards compatible.  All existing tests
pass.  For example, the above PHPUnit snipped would become:

 use A\Namespaced\ClassName;
 $mock = $this->getMock(ClassName::class);

Another example with reflection:

 use SomeOther\FullyNamespaced\ClassElsewhere as CE;
 $r = new ReflectionClass(CE::class);

More examples from the test file:

 namespace Foo\Bar {
   class Baz {}
   var_dump(Moo::CLASS); // "Foo\Bar\Moo"
 }

 namespace {
   use Bee\Bop as Moo,
       Foo\Bar\Baz;

   var_dump(Baz::class); // "Foo\Bar\Baz"
   var_dump(Boo::class); // "Boo"
   var_dump(Moo::CLASS); // "Bee\Bop"
   var_dump(\Moo::Class); // "Moo"

   $class = Baz::class; // assign class as scalar to var
   $x = new $class;
   var_dump($x);  object(Foo\Bar\Baz)#1 (0) {}
 }

What do you guys think?

-ralph

--

Hi, Ralph

I really like this feature in general.

One thing I personally dislike in this implementation is the
difference between CLASS and class ... One with and one without
namespaces ...
If we can unify that, this would be a great help in understanding that
feature in future and getting the difference while reading code.
And please don't forget: Code will be written once, maybe rewritten
some times, but it will be read way more times!

Bye
Simon

So, at current, is this small enough for just a pull request, or does
this deserve its own RFC?

-ralph

Hi all,

There are many different use cases were in code we expect classes names
as arguments to functions as fully qualified names. We do this in ZF a
lot with our Service Location and DI components, but also with our code
reflection API, etc. A more interesting use case I would like to call
out is with PHPUnit, for example in a test, you might find this:

$mock = $this->getMock('A\Namespaced\ClassName');

This becomes cumbersome when you are dealing with lots of strings about
lots of class names. This is also an area where, currently, namespace
declaration and use statements offer no real support.

The patch located here:

https://github.com/ralphschindler/php-src/commit/02210d51851a96d723fbedcfc64cde9f9ae2b22a

... implements the ability for a developer to leverage the file's
namespace declaration and use statements to be able to produce a scalar
(string) of the class name that can be then used, for example, as an
argument to a function elsewhere.

This overloads the "class" keyword, and by virtue of the existing usage
of "class" this feature is completely backwards compatible. All existing
tests pass. For example, the above PHPUnit snipped would become:

use A\Namespaced\ClassName;
$mock = $this->getMock(ClassName::class);

Another example with reflection:

use SomeOther\FullyNamespaced\ClassElsewhere as CE;
$r = new ReflectionClass(CE::class);

More examples from the test file:

namespace Foo\Bar {
class Baz {}
var_dump(Moo::CLASS); // "Foo\Bar\Moo"
}

namespace {
use Bee\Bop as Moo,
Foo\Bar\Baz;

var_dump(Baz::class); // "Foo\Bar\Baz"
var_dump(Boo::class); // "Boo"
var_dump(Moo::CLASS); // "Bee\Bop"
var_dump(\Moo::Class); // "Moo"

$class = Baz::class; // assign class as scalar to var
$x = new $class;
var_dump($x); object(Foo\Bar\Baz)#1 (0) {}
}

What do you guys think?

-ralph

On Sat, Apr 14, 2012 at 9:50 PM, Ralph Schindler
ralph@ralphschindler.com wrote:

Hi all,

There are many different use cases were in code we expect classes names as
arguments to functions as fully qualified names.  We do this in ZF a lot
with our Service Location and DI components, but also with our code
reflection API, etc.  A more interesting use case I would like to call out
is with PHPUnit, for example in a test, you might find this:

 $mock = $this->getMock('A\Namespaced\ClassName');

This becomes cumbersome when you are dealing with lots of strings about lots
of class names.  This is also an area where, currently, namespace
declaration and use statements offer no real support.

The patch located here:

https://github.com/ralphschindler/php-src/commit/02210d51851a96d723fbedcfc64cde9f9ae2b22a

... implements the ability for a developer to leverage the file's namespace
declaration and use statements to be able to produce a scalar (string) of
the class name that can be then used, for example, as an argument to a
function elsewhere.

This overloads the "class" keyword, and by virtue of the existing usage of
"class" this feature is completely backwards compatible.  All existing tests
pass.  For example, the above PHPUnit snipped would become:

 use A\Namespaced\ClassName;
 $mock = $this->getMock(ClassName::class);

Another example with reflection:

 use SomeOther\FullyNamespaced\ClassElsewhere as CE;
 $r = new ReflectionClass(CE::class);

More examples from the test file:

 namespace Foo\Bar {
   class Baz {}
   var_dump(Moo::CLASS); // "Foo\Bar\Moo"
 }

 namespace {
   use Bee\Bop as Moo,
       Foo\Bar\Baz;

   var_dump(Baz::class); // "Foo\Bar\Baz"
   var_dump(Boo::class); // "Boo"
   var_dump(Moo::CLASS); // "Bee\Bop"
   var_dump(\Moo::Class); // "Moo"

   $class = Baz::class; // assign class as scalar to var
   $x = new $class;
   var_dump($x);  object(Foo\Bar\Baz)#1 (0) {}
 }

What do you guys think?
Hey Ralph!

I like the proposal :)

A quick note on the patch: As the class name is compile-time
resolvable it should in my eyes also be available as a
static_scalar, so that it can be used in initialization lists:

public function doFoo($withClass = ABC::class) {
    new $withClass; // or whatever
}

To be available as both a static_scalar and a general scalar one
should put the rule in the common_scalar section.

What do you think?

Nikita

I'm a bit confused by the "class" keyword in the syntax ClassName::class.
We already have the magic constant CLASS which does exactly the same
class name resolving, if you refer it within the class.

So why to introduce a new keyword instead of using CLASS, like
ClassName::CLASS?

Eugene

"Ralph Schindler" ralph@ralphschindler.com wrote in message
news:4F89D4F1.8070009@ralphschindler.com...

Hi all,

There are many different use cases were in code we expect classes names as
arguments to functions as fully qualified names. We do this in ZF a lot
with our Service Location and DI components, but also with our code
reflection API, etc. A more interesting use case I would like to call out
is with PHPUnit, for example in a test, you might find this:

$mock = $this->getMock('A\Namespaced\ClassName');

This becomes cumbersome when you are dealing with lots of strings about
lots of class names. This is also an area where, currently, namespace
declaration and use statements offer no real support.

The patch located here:

https://github.com/ralphschindler/php-src/commit/02210d51851a96d723fbedcfc64cde9f9ae2b22a

... implements the ability for a developer to leverage the file's
namespace declaration and use statements to be able to produce a scalar
(string) of the class name that can be then used, for example, as an
argument to a function elsewhere.

This overloads the "class" keyword, and by virtue of the existing usage of
"class" this feature is completely backwards compatible. All existing
tests pass. For example, the above PHPUnit snipped would become:

use A\Namespaced\ClassName;
$mock = $this->getMock(ClassName::class);

Another example with reflection:

use SomeOther\FullyNamespaced\ClassElsewhere as CE;
$r = new ReflectionClass(CE::class);

More examples from the test file:

namespace Foo\Bar {
class Baz {}
var_dump(Moo::CLASS); // "Foo\Bar\Moo"
}

namespace {
use Bee\Bop as Moo,
Foo\Bar\Baz;

var_dump(Baz::class); // "Foo\Bar\Baz"
var_dump(Boo::class); // "Boo"
var_dump(Moo::CLASS); // "Bee\Bop"
var_dump(\Moo::Class); // "Moo"

$class = Baz::class; // assign class as scalar to var
$x = new $class;
var_dump($x);  object(Foo\Bar\Baz)#1 (0) {}

}

What do you guys think?

-ralph

Would it be easy to have a patch that simply allows use of the class name,
or is the "::class" suffix necessary to resolve some ambiguity? Example
usage:

   $mock = $this->getMock(A\Namespaced**ClassName);
   # or
   use A\Namespaced\ClassName;
   $mock = $this->getMock(ClassName);

Would changing the definition for class_name_scalar be sufficient?

   class_name_scalar:
       class_name { zend_resolve_class_name(&$1, ZEND_FETCH_CLASS_GLOBAL,
1 TSRMLS_CC); $$ = $1;  }
   ;

To my eye, this is the least surprising syntax.
In your above example ClassName could just as well be a constant :)

Nikita

Would changing the definition for class_name_scalar be sufficient?

 class_name_scalar:
     class_name { zend_resolve_class_name(&$1, ZEND_FETCH_CLASS_GLOBAL,

1 TSRMLS_CC); $$ = $1; }
;

To my eye, this is the least surprising syntax.

As far as I can tell, this rule will not compile as it conflicts with
other rules, namely around the namespace implementation rules.

Besides that though, an original design goal was to implement it closer
to how other languages solve the same-ish problem. This solution is
somewhat in line with Java (.class) and Ruby (.class.name), Python
actually uses the same but instead of .class, they use .class.name

-ralph

Hi!

As already mentioned, There can't be a class constant called "class",
because it is a keyword. (const class = 'Foo' is a syntax error).

It looks like class constant. So it should work like one (or, in this
case, not work since as you noticed there can not be one).

But yes, I agree that runtime resolution only duplicates existing
behavior, so it isn't really necessary (you could argue thought that
self::class similarly also only replicates the existing CLASS). It
would be nice for consistency in my eyes, but I'm good without it too

I do not see any "consistency" in creating functionality that is not
needed and collides with existing syntax and actually works completely
different even though it looks the same. Not much sense to have
$foo::bar and $foo::class mean completely different things. foo::bar is
static constant expression, so is foo::class, but static::class and
$foo::class won't be. It all would be very confusing. I suggest limiting
ourselves to constant expressions like foo::class, self::class and
parent::class.

Stanislav Malyshev, Software Architect
SugarCRM: http://www.sugarcrm.com/
(408)454-6900 ext. 227