what problem do you want to solve?

you don't need the () at all unless you want to provide parameters for a constructor - so you save exactly one char for what benefit?

But...why?

An object is an instance of a class. There are anonymous functions for closures. A request like this should be discussed on internals, and has been discussed on internals in the past:

https://externals.io/message/106947

Proposed and discussed a few times. But reconsider whether you really need so many stdClass objects or whether some concrete types would be better.

Note that [] isn't a really shorthand: both array syntaxes look and work the same way, except one starts with "[" and ends with "]" while the other starts with "array(" and ends with ")". Meanwhile objects have no corresponding syntax at all - long or short.

Perhaps that's because stdClass is a second-class citizen (pun intended) after arrays and "real" classes. And while they're commonly used for comparisons, objects in Javascript are more closely related to PHP's associative arrays; PHP's objects are closer to traditional OOP classes, plus some added dynamic features.

why an object must be an instance of a class;
and cannot be a native type; being able to create an object as an array is created can help just as the method of creating short arrays has helped.

the question should not be why; the question should be why not implement something like that?

Are you familiar with object-oriented programming? I recommend reading up on it and then reading further into advanced topics of OOP and class-design. 

The design decisions behind using a short-syntax often lead to difficult-to-maintain or even unmaintainable code because the code typically becomes difficult to understand and fit all of it inside of one's mind.

Ask yourself why you can't create a class instead, then instantiate a new object of that class? Occasionally, using a static method inside a class works wonders too.

For developers, more time is spent reading and understanding code than writing code.

I will try to explain in a better way.

Currently we can declare an array and then cast it to an object in the following way:

$obj1 = (object)[
    'prop1'=>'string',
	'prop2'=>true,
	'prop3'=>12,
]; //this option exist

other way:

$obj1 = new stdClass();
$obj1->prop1 = 'string';
$obj1->prop2 = true;
$obj1->prop3 = 12;
//this option exist

I think this is done this way to save time on data development and handling; for when required ... I have implemented OOP.

It seems to me that we need anonymous objects or a more obvious way to declare them, avoiding going through the new stdclass() or Array Casting; why doing object() can have the same result or if you do something like:

$obj = {
	'prop1'=>'string',
	'prop2'=>true,
	'prop3'=>12,
}; //this option not exist

Or

$obj = object(
	'prop1'=>'string',
	'prop2'=>true,
	'prop3'=>12,
); //this option not exist

the use would be the same:

$obj->prop1;

the output would be:

object(stdClass)#1 (3) {
  ["prop1"]=>
  string(6) "string"
  ["prop2"]=>
  bool(true)
  ["prop3"]=>
  int(12)
}

it's an idea ... it shouldn't be a trauma.

Your example can be accomplished just as easily with an array, given that an anonymous/stdClass object does not support code analysis or IDE autocompletion or phpDoc tags. The only difference (besides writing [] vs. ->) is that a modification to the object will also affect the original, while with arrays any modification made would be to a copy - so actually, using an object could result in some rather nasty bugs.

If you have specific named properties then you should probably be using a concrete class. Even if that class is a simple "struct" like

  class ThingWithProps {
    public string $prop1;
    public bool $prop2;
    public int $prop3;
    // possibly with a constructor
  }

or, as of PHP 8.0,

  class ThingWithProps {
    public function __construct( 
      public string $prop1,
      public bool $prop2,
      public int $prop3
    ) { }
  }