MixedType returns valid properties, methods and constants

src/Reflection/Dummy/DummyMethodReflection.php

@@ -0,0 +1,73 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Reflection\Dummy;
+
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\ClassMemberReflection;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class DummyMethodReflection implements MethodReflection
+{
+
+	/** @var string */
+	private $name;
+
+	public function __construct(string $name)
+	{
+		$this->name = $name;
+	}
+
+	public function getDeclaringClass(): ClassReflection
+	{
+		$broker = Broker::getInstance();
+
+		return $broker->getClass(\stdClass::class);
+	}
+
+	public function isStatic(): bool
+	{
+		return false;
+	}
+
+	public function isPrivate(): bool
+	{
+		return false;
+	}
+
+	public function isPublic(): bool
+	{
+		return true;
+	}
+
+	public function getName(): string
+	{
+		return $this->name;
+	}
+
+	public function getPrototype(): ClassMemberReflection
+	{
+		return $this;
+	}
+
+	/**
+	 * @return \PHPStan\Reflection\ParameterReflection[]
+	 */
+	public function getParameters(): array
+	{
+		return [];
+	}
+
+	public function isVariadic(): bool
+	{
+		return true;
+	}
+
+	public function getReturnType(): Type
+	{
+		return new MixedType();
+	}
+
+}

src/Reflection/Dummy/DummyPropertyReflection.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Reflection\Dummy;
+
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\PropertyReflection;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class DummyPropertyReflection implements PropertyReflection
+{
+
+	public function getDeclaringClass(): ClassReflection
+	{
+		$broker = Broker::getInstance();
+
+		return $broker->getClass(\stdClass::class);
+	}
+
+	public function isStatic(): bool
+	{
+		return false;
+	}
+
+	public function isPrivate(): bool
+	{
+		return false;
+	}
+
+	public function isPublic(): bool
+	{
+		return true;
+	}
+
+	public function getType(): Type
+	{
+		return new MixedType();
+	}
+
+	public function isReadable(): bool
+	{
+		return true;
+	}
+
+	public function isWritable(): bool
+	{
+		return true;
+	}
+
+}

src/Type/MixedType.php

@@ -2,10 +2,15 @@
 
 namespace PHPStan\Type;
 
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ClassConstantReflection;
+use PHPStan\Reflection\Dummy\DummyMethodReflection;
+use PHPStan\Reflection\Dummy\DummyPropertyReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\PropertyReflection;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Traits\MaybeCallableTypeTrait;
 use PHPStan\Type\Traits\MaybeIterableTypeTrait;
-use PHPStan\Type\Traits\MaybeObjectTypeTrait;
 use PHPStan\Type\Traits\MaybeOffsetAccessibleTypeTrait;
 use PHPStan\Type\Traits\UndecidedBooleanTypeTrait;
 
@@ -14,7 +19,6 @@ class MixedType implements CompoundType
 
 	use MaybeCallableTypeTrait;
 	use MaybeIterableTypeTrait;
-	use MaybeObjectTypeTrait;
 	use MaybeOffsetAccessibleTypeTrait;
 	use UndecidedBooleanTypeTrait;
 
@@ -53,6 +57,56 @@ public function isSubTypeOf(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function canAccessProperties(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
+	public function hasProperty(string $propertyName): bool
+	{
+		return true;
+	}
+
+	public function getProperty(string $propertyName, Scope $scope): PropertyReflection
+	{
+		return new DummyPropertyReflection();
+	}
+
+	public function canCallMethods(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
+	public function hasMethod(string $methodName): bool
+	{
+		return true;
+	}
+
+	public function getMethod(string $methodName, Scope $scope): MethodReflection
+	{
+		return new DummyMethodReflection($methodName);
+	}
+
+	public function canAccessConstants(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
+	public function hasConstant(string $constantName): bool
+	{
+		return false;
+	}
+
+	public function getConstant(string $constantName): ClassConstantReflection
+	{
+		throw new \PHPStan\ShouldNotHappenException();
+	}
+
+	public function isCloneable(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
 	public function describe(VerbosityLevel $level): string
 	{
 		return 'mixed';

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -5602,6 +5602,49 @@ public function testArrayKeysInBranches(
 		);
 	}
 
+	public function dataElementsOnMixed(): array
+	{
+		return [
+			[
+				'mixed',
+				'$mixed->foo',
+			],
+			[
+				'mixed',
+				'$mixed->foo->bar',
+			],
+			[
+				'mixed',
+				'$mixed->foo()',
+			],
+			[
+				'mixed',
+				'$mixed->foo()->bar()',
+			],
+			[
+				'mixed',
+				'$mixed::TEST_CONSTANT',
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider dataElementsOnMixed
+	 * @param string $description
+	 * @param string $expression
+	 */
+	public function testElementsOnMixed(
+		string $description,
+		string $expression
+	): void
+	{
+		$this->assertTypes(
+			__DIR__ . '/data/mixed-elements.php',
+			$description,
+			$expression
+		);
+	}
+
 	private function assertTypes(
 		string $file,
 		string $description,

tests/PHPStan/Analyser/data/mixed-elements.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace MixedElements;
+
+function ($mixed) {
+	die;
+};

tests/PHPStan/Rules/Operators/data/invalid-binary.php

@@ -98,3 +98,9 @@ function ()
 		$result['allowedRoomCounter'] += $x;
 	}
 };
+
+function () {
+	$o = new stdClass;
+	$o->user ?? '';
+	$o->user->name ?? '';
+};