How come in PHP this works:
$myClass = 'App\MyClass';
$object = new $myClass;
But this results in an error:
$myClass = 'MyClass';
$object = new 'App\\'.$myClass;
In the second example, an unexpected T_CONSTANT_ENCAPSED_STRING is thrown.
As it turns out, the above example is due to operator precedence since new takes highest precedence, but...
Similarly, I can try instantiating with just a string as in:
$object = new 'App\MyClass';
And the same error is thrown. Why is this?
The parser's implementation is not generic, therefore in some cases the parser would hiccup over things the engine could in fact handle. There (still) isn't even an official formal grammar for PHP, which makes it hard to predict things like this, without simply trying them out. It's the way of the PHP world :)
PHP expects a variable or name reference for object definitions, it simply won't allow strings. You can use this hack which is based on '' empty string named variable the is instantly created and used based on the fact that ${false} evaluates to ${''} as follows to create an object from string:
$obj = new ${!${''} = 'App\MyClass'}();
PHPs syntax is defined in zend_language_parser.y, and it simply doesn't define any more complex expressions for the new operator:
new_expr:
T_NEW class_name_reference ctor_arguments
{ $$ = zend_ast_create(ZEND_AST_NEW, $2, }
| T_NEW anonymous_class
{ $$ = $2; }
Where class_name_reference is:
class_name_reference:
class_name { $$ = $1; }
| new_variable { $$ = $1; }
And new_variable allows for a limited set of variable expressions:
new_variable:
simple_variable
{ $$ = zend_ast_create(ZEND_AST_VAR, $1); }
| new_variable '[' optional_expr ']'
{ $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); }
| new_variable '{' expr '}'
{ $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); }
| new_variable T_OBJECT_OPERATOR property_name
{ $$ = zend_ast_create(ZEND_AST_PROP, $1, $3); }
| class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable
{ $$ = zend_ast_create(ZEND_AST_STATIC_PROP, $1, $3); }
| new_variable T_PAAMAYIM_NEKUDOTAYIM simple_variable
{ $$ = zend_ast_create(ZEND_AST_STATIC_PROP, $1, $3); }
// Copyright (c) 1998-2015 Zend Technologies Ltd., the Zend license 2.00
Which is why you can't have string expressions there. (It was never extended, because the trivial instantiations and $classvarnames are often sufficient. So the allowed syntax is mostly the same as in PHP3, when it was introduced.)
This is because of operator precedence: http://php.net/manual/en/language.operators.precedence.php
Since 'new' has a higher precedence than '.' it gets processed first.
As far as your code goes, what the compiler sees is:
$myClass = 'MyClass';
$object = new 'App\\';
$object = $object . $myClass;
For the second part of your question, why: $object = new 'App\MyClass'; doesn't work. I am unsure.
If I had to guess I would say it is because when you do new 'App\MyClass', the parser doesn't know it is a string when it encounters it. Until the line has been processed it doesn't know if it is dealing with a string, number, object, etc. It could discover that and properly cast it to a string but I would guess this comes back to operator precedence where it doesn't do those type of casts until after handling the 'new' operator.
Curiously, I just tested it in Quercus PHP and it runs fine. As other people have mentioned, php isn't a fully defined language so things like this manifest as differences between implementations.
$object = new 'App\MyClass';
T_NEW class_name_reference|new_variable ctor_arguments. It only allows literal names, or variables, and some variable expressions, but not string expressions.