@@ -22,6 +22,7 @@ It also contains this strict framework-specific rules (can be enabled separately
 * Check that you are not using `assertSame()` with `false` as expected value. `assertFalse()` should be used instead.
 * Check that you are not using `assertSame()` with `null` as expected value. `assertNull()` should be used instead.
 * Check that you are not using `assertSame()` with `count($variable)` as second parameter. `assertCount($variable)` should be used instead.
+* Check that you are not using `assertEquals()` with same types (`assertSame()` should be used)
 
 ## How to document mock objects in phpDocs?
 

@@ -0,0 +1,64 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PHPUnit;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\CallLike;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\GeneralizePrecision;
+use PHPStan\Type\TypeCombinator;
+use function count;
+use function strtolower;
+
+/**
+* @implements Rule<CallLike>
+*/
+class AssertEqualsIsDiscouragedRule implements Rule
+{
+
+public function getNodeType(): string
+{
+return CallLike::class;
+}
+
+public function processNode(Node $node, Scope $scope): array
+{
+if (!AssertRuleHelper::isMethodOrStaticCallOnAssert($node, $scope)) {
+return [];
+}
+
+if (count($node->getArgs()) < 2) {
+return [];
+}
+if (!$node->name instanceof Node\Identifier || strtolower($node->name->name) !== 'assertequals') {
+return [];
+}
+
+$leftType = TypeCombinator::removeNull($scope->getType($node->getArgs()[0]->value));
+$rightType = TypeCombinator::removeNull($scope->getType($node->getArgs()[1]->value));
+
+if ($leftType->isConstantScalarValue()->yes()) {
+$leftType = $leftType->generalize(GeneralizePrecision::lessSpecific());
+}
+if ($rightType->isConstantScalarValue()->yes()) {
+$rightType = $rightType->generalize(GeneralizePrecision::lessSpecific());
+}
+
+if (
+($leftType->isScalar()->yes() && $rightType->isScalar()->yes())
+&& ($leftType->isSuperTypeOf($rightType)->yes())
+&& ($rightType->isSuperTypeOf($leftType)->yes())
+) {
+return [
+RuleErrorBuilder::message(
+'You should use assertSame() instead of assertEquals(), because both values are scalars of the same type',
+)->identifier('phpunit.assertEquals')->build(),
+];
+}
+
+return [];
+}
+
+}

@@ -0,0 +1,38 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PHPUnit;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+* @extends RuleTestCase<AssertEqualsIsDiscouragedRule>
+*/
+final class AssertEqualsIsDiscouragedRuleTest extends RuleTestCase
+{
+
+private const ERROR_MESSAGE = 'You should use assertSame() instead of assertEquals(), because both values are scalars of the same type';
+
+public function testRule(): void
+{
+$this->analyse([__DIR__ . '/data/assert-equals-is-discouraged.php'], [
+[self::ERROR_MESSAGE, 19],
+[self::ERROR_MESSAGE, 22],
+[self::ERROR_MESSAGE, 23],
+[self::ERROR_MESSAGE, 24],
+[self::ERROR_MESSAGE, 25],
+[self::ERROR_MESSAGE, 26],
+[self::ERROR_MESSAGE, 27],
+[self::ERROR_MESSAGE, 28],
+[self::ERROR_MESSAGE, 29],
+[self::ERROR_MESSAGE, 30],
+[self::ERROR_MESSAGE, 32],
+]);
+}
+
+protected function getRule(): Rule
+{
+return new AssertEqualsIsDiscouragedRule();
+}
+
+}

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SameOverEqualsTest;
+
+use Exception;
+use PHPUnit\Framework\TestCase;
+
+final class AssertSameOverAssertEqualsRule extends TestCase
+{
+public function dummyTest(string $string, int $integer,	bool $boolean, float $float, ?string $nullableString): void
+{
+$null = null;
+
+$this->assertSame(5, $integer);
+static::assertSame(5, $integer);
+
+$this->assertEquals('', $string);
+$this->assertEquals(null, $string);
+static::assertEquals(null, $string);
+static::assertEquals($nullableString, $string);
+$this->assertEquals(2, $integer);
+$this->assertEquals(2.2, $float);
+static::assertEquals((int) '2', (int) $string);
+$this->assertEquals(true, $boolean);
+$this->assertEquals($string, $string);
+$this->assertEquals($integer, $integer);
+$this->assertEquals($boolean, $boolean);
+$this->assertEquals($float, $float);
+$this->assertEquals($null, $null);
+$this->assertEquals((string) new Exception(), (string) new Exception());
+$this->assertEquals([], []);
+$this->assertEquals(new Exception(), new Exception());
+static::assertEquals(new Exception(), new Exception());
+}
+}