Remove AbstractExpressionEncoder and ExpressionEncoder interface

GromNaN · GromNaN · commit 305eab4be0f5 · 2025-02-26T10:47:19.000+01:00
diff --git a/psalm-baseline.xml b/psalm-baseline.xml
@@ -46,13 +46,6 @@
       <code><![CDATA[$encoder->encode($value)]]></code>
     </MixedReturnStatement>
   </file>
-  <file src="src/Builder/Encoder/AbstractExpressionEncoder.php">
-    <MixedAssignment>
-      <code><![CDATA[$val]]></code>
-      <code><![CDATA[$val]]></code>
-      <code><![CDATA[$value[$key]]]></code>
-    </MixedAssignment>
-  </file>
   <file src="src/Builder/Encoder/CombinedFieldQueryEncoder.php">
     <MixedAssignment>
       <code><![CDATA[$filter]]></code>
@@ -104,6 +97,13 @@
       <code><![CDATA[$value]]></code>
     </MixedAssignment>
   </file>
+  <file src="src/Builder/Encoder/RecursiveEncode.php">
+    <MixedAssignment>
+      <code><![CDATA[$val]]></code>
+      <code><![CDATA[$val]]></code>
+      <code><![CDATA[$value[$key]]]></code>
+    </MixedAssignment>
+  </file>
   <file src="src/Builder/Query.php">
     <ArgumentTypeCoercion>
       <code><![CDATA[$query]]></code>
diff --git a/src/Builder/BuilderEncoder.php b/src/Builder/BuilderEncoder.php
@@ -9,7 +9,6 @@
 use MongoDB\Builder\Encoder\CombinedFieldQueryEncoder;
 use MongoDB\Builder\Encoder\DateTimeEncoder;
 use MongoDB\Builder\Encoder\DictionaryEncoder;
-use MongoDB\Builder\Encoder\ExpressionEncoder;
 use MongoDB\Builder\Encoder\FieldPathEncoder;
 use MongoDB\Builder\Encoder\OperatorEncoder;
 use MongoDB\Builder\Encoder\OutputWindowEncoder;
@@ -33,14 +32,15 @@
 
 use function array_key_exists;
 use function is_object;
+use function is_string;
 
 /** @template-implements Encoder<Type|stdClass|array|string|int, Pipeline|StageInterface|ExpressionInterface|QueryInterface> */
 final class BuilderEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<Type|stdClass|array|string|int, Pipeline|StageInterface|ExpressionInterface|QueryInterface> */
     use EncodeIfSupported;
 
-    /** @var array<class-string, class-string<ExpressionEncoder>> */
+    /** @var array<class-string, class-string<Encoder>> */
     private array $defaultEncoders = [
         Pipeline::class => PipelineEncoder::class,
         Variable::class => VariableEncoder::class,
diff --git a/src/Builder/Encoder/CombinedFieldQueryEncoder.php b/src/Builder/Encoder/CombinedFieldQueryEncoder.php
@@ -7,6 +7,7 @@
 use LogicException;
 use MongoDB\Builder\Type\CombinedFieldQuery;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 use stdClass;
 
@@ -17,13 +18,14 @@
 use function sprintf;
 
 /**
- * @template-extends AbstractExpressionEncoder<stdClass, CombinedFieldQuery>
+ * @template-implements Encoder<stdClass, CombinedFieldQuery>
  * @internal
  */
-final class CombinedFieldQueryEncoder extends AbstractExpressionEncoder
+final class CombinedFieldQueryEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<stdClass, CombinedFieldQuery> */
     use EncodeIfSupported;
+    use RecursiveEncode;
 
     public function canEncode(mixed $value): bool
     {
diff --git a/src/Builder/Encoder/DateTimeEncoder.php b/src/Builder/Encoder/DateTimeEncoder.php
@@ -7,13 +7,14 @@
 use DateTimeInterface;
 use MongoDB\BSON\UTCDateTime;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 
 /**
- * @template-extends AbstractExpressionEncoder<UTCDateTime, DateTimeInterface>
+ * @template-implements Encoder<UTCDateTime, DateTimeInterface>
  * @internal
  */
-final class DateTimeEncoder extends AbstractExpressionEncoder
+final class DateTimeEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<UTCDateTime, DateTimeInterface> */
     use EncodeIfSupported;
diff --git a/src/Builder/Encoder/DictionaryEncoder.php b/src/Builder/Encoder/DictionaryEncoder.php
@@ -6,14 +6,15 @@
 
 use MongoDB\Builder\Type\DictionaryInterface;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 use stdClass;
 
 /**
- * @template-extends AbstractExpressionEncoder<string|int|array|stdClass, DictionaryInterface>
+ * @template-implements Encoder<string|int|array|stdClass, DictionaryInterface>
  * @internal
  */
-final class DictionaryEncoder extends AbstractExpressionEncoder
+final class DictionaryEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<string|int|array|stdClass, DictionaryInterface> */
     use EncodeIfSupported;
diff --git a/src/Builder/Encoder/ExpressionEncoder.php b/src/Builder/Encoder/ExpressionEncoder.php
diff --git a/src/Builder/Encoder/FieldPathEncoder.php b/src/Builder/Encoder/FieldPathEncoder.php
@@ -6,13 +6,14 @@
 
 use MongoDB\Builder\Type\FieldPathInterface;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 
 /**
- * @template-extends AbstractExpressionEncoder<string, FieldPathInterface>
+ * @template-implements Encoder<string, FieldPathInterface>
  * @internal
  */
-final class FieldPathEncoder extends AbstractExpressionEncoder
+final class FieldPathEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<string, FieldPathInterface> */
     use EncodeIfSupported;
diff --git a/src/Builder/Encoder/OperatorEncoder.php b/src/Builder/Encoder/OperatorEncoder.php
@@ -9,6 +9,7 @@
 use MongoDB\Builder\Type\OperatorInterface;
 use MongoDB\Builder\Type\Optional;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 use stdClass;
 
@@ -17,13 +18,14 @@
 use function sprintf;
 
 /**
- * @template-extends AbstractExpressionEncoder<stdClass, OperatorInterface>
+ * @template-implements Encoder<stdClass, OperatorInterface>
  * @internal
  */
-final class OperatorEncoder extends AbstractExpressionEncoder
+final class OperatorEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<stdClass, OperatorInterface> */
     use EncodeIfSupported;
+    use RecursiveEncode;
 
     public function canEncode(mixed $value): bool
     {
diff --git a/src/Builder/Encoder/OutputWindowEncoder.php b/src/Builder/Encoder/OutputWindowEncoder.php
@@ -9,6 +9,7 @@
 use MongoDB\Builder\Type\OutputWindow;
 use MongoDB\Builder\Type\WindowInterface;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 use stdClass;
 
@@ -18,13 +19,14 @@
 use function sprintf;
 
 /**
- * @template-extends AbstractExpressionEncoder<stdClass, OutputWindow>
+ * @template-implements Encoder<stdClass, OutputWindow>
  * @internal
  */
-final class OutputWindowEncoder extends AbstractExpressionEncoder
+final class OutputWindowEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<stdClass, OutputWindow> */
     use EncodeIfSupported;
+    use RecursiveEncode;
 
     public function canEncode(mixed $value): bool
     {
diff --git a/src/Builder/Encoder/PipelineEncoder.php b/src/Builder/Encoder/PipelineEncoder.php
@@ -6,16 +6,18 @@
 
 use MongoDB\Builder\Pipeline;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 
 /**
- * @template-extends AbstractExpressionEncoder<list<mixed>, Pipeline>
+ * @template-implements Encoder<list<mixed>, Pipeline>
  * @internal
  */
-final class PipelineEncoder extends AbstractExpressionEncoder
+final class PipelineEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<list<mixed>, Pipeline> */
     use EncodeIfSupported;
+    use RecursiveEncode;
 
     /** @psalm-assert-if-true Pipeline $value */
     public function canEncode(mixed $value): bool
@@ -32,7 +34,7 @@ public function encode(mixed $value): array
 
         $encoded = [];
         foreach ($value->getIterator() as $stage) {
-            $encoded[] = $this->encoder->encodeIfSupported($stage);
+            $encoded[] = $this->recursiveEncode($stage);
         }
 
         return $encoded;
diff --git a/src/Builder/Encoder/QueryEncoder.php b/src/Builder/Encoder/QueryEncoder.php
@@ -8,6 +8,7 @@
 use MongoDB\Builder\Type\QueryInterface;
 use MongoDB\Builder\Type\QueryObject;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 use stdClass;
 
@@ -16,13 +17,14 @@
 use function sprintf;
 
 /**
- * @template-extends AbstractExpressionEncoder<stdClass, QueryObject>
+ * @template-implements Encoder<stdClass, QueryObject>
  * @internal
  */
-final class QueryEncoder extends AbstractExpressionEncoder
+final class QueryEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<stdClass, QueryObject> */
     use EncodeIfSupported;
+    use RecursiveEncode;
 
     public function canEncode(mixed $value): bool
     {
diff --git a/src/Builder/Encoder/RecursiveEncode.php b/src/Builder/Encoder/RecursiveEncode.php
@@ -4,20 +4,13 @@
 
 namespace MongoDB\Builder\Encoder;
 
-use MongoDB\BSON\Type;
 use MongoDB\Builder\BuilderEncoder;
 use stdClass;
 
 use function get_object_vars;
 use function is_array;
 
-/**
- * @template BSONType of Type|stdClass|array|string|int
- * @template NativeType
- * @template-implements ExpressionEncoder<BSONType, NativeType>
- * @internal
- */
-abstract class AbstractExpressionEncoder implements ExpressionEncoder
+trait RecursiveEncode
 {
     final public function __construct(protected readonly BuilderEncoder $encoder)
     {
@@ -33,7 +26,7 @@ final public function __construct(protected readonly BuilderEncoder $encoder)
      *
      * @template T
      */
-    final protected function recursiveEncode(mixed $value): mixed
+    private function recursiveEncode(mixed $value): mixed
     {
         if (is_array($value)) {
             foreach ($value as $key => $val) {
diff --git a/src/Builder/Encoder/VariableEncoder.php b/src/Builder/Encoder/VariableEncoder.php
@@ -6,13 +6,14 @@
 
 use MongoDB\Builder\Expression\Variable;
 use MongoDB\Codec\EncodeIfSupported;
+use MongoDB\Codec\Encoder;
 use MongoDB\Exception\UnsupportedValueException;
 
 /**
- * @template-extends AbstractExpressionEncoder<string, Variable>
+ * @template-implements Encoder<string, Variable>
  * @internal
  */
-final class VariableEncoder extends AbstractExpressionEncoder
+final class VariableEncoder implements Encoder
 {
     /** @template-use EncodeIfSupported<string, Variable> */
     use EncodeIfSupported;
diff --git a/tests/Builder/BuilderEncoderTest.php b/tests/Builder/BuilderEncoderTest.php
@@ -424,9 +424,8 @@ public function encode(mixed $value)
     }
 
     /** @param list<array<string, mixed>> $expected */
-    private static function assertSamePipeline(array $expected, Pipeline $pipeline): void
+    private static function assertSamePipeline(array $expected, Pipeline $pipeline, $codec = new BuilderEncoder()): void
     {
-        $codec = new BuilderEncoder();
         $actual = $codec->encode($pipeline);
 
         // Normalize with BSON round-trip

Original file line number	Diff line number	Diff line change
`@@ -424,9 +424,8 @@ public function encode(mixed $value)`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`/** @param list<array<string, mixed>> $expected */`
`427`		`- private static function assertSamePipeline(array $expected, Pipeline $pipeline): void`
	`427`	`+ private static function assertSamePipeline(array $expected, Pipeline $pipeline, $codec = new BuilderEncoder()): void`
`428`	`428`	`{`
`429`		`- $codec = new BuilderEncoder();`
`430`	`429`	`$actual = $codec->encode($pipeline);`
`431`	`430`
`432`	`431`	`// Normalize with BSON round-trip`