misc: move setting values in shell

This, for instance, allows to more easily check for unexpected keys in
the source.

src/Library/Container.php

@@ -86,36 +86,37 @@ public function __construct(Settings $settings)
         $this->factories = [
             TreeMapper::class => fn () => new TypeTreeMapper(
                 $this->get(TypeParser::class),
-                $this->get(RootNodeBuilder::class)
+                $this->get(RootNodeBuilder::class),
+                $settings,
             ),
 
             ArgumentsMapper::class => fn () => new TypeArgumentsMapper(
                 $this->get(FunctionDefinitionRepository::class),
-                $this->get(RootNodeBuilder::class)
+                $this->get(RootNodeBuilder::class),
+                $settings,
             ),
 
             RootNodeBuilder::class => fn () => new RootNodeBuilder(
                 $this->get(NodeBuilder::class)
             ),
 
             NodeBuilder::class => function () use ($settings) {
-                $listNodeBuilder = new ListNodeBuilder($settings->enableFlexibleCasting);
-                $arrayNodeBuilder = new ArrayNodeBuilder($settings->enableFlexibleCasting);
+                $listNodeBuilder = new ListNodeBuilder();
+                $arrayNodeBuilder = new ArrayNodeBuilder();
 
                 $builder = new CasterNodeBuilder([
                     ListType::class => $listNodeBuilder,
                     NonEmptyListType::class => $listNodeBuilder,
                     ArrayType::class => $arrayNodeBuilder,
                     NonEmptyArrayType::class => $arrayNodeBuilder,
                     IterableType::class => $arrayNodeBuilder,
-                    ShapedArrayType::class => new ShapedArrayNodeBuilder($settings->allowSuperfluousKeys),
-                    ScalarType::class => new ScalarNodeBuilder($settings->enableFlexibleCasting),
+                    ShapedArrayType::class => new ShapedArrayNodeBuilder(),
+                    ScalarType::class => new ScalarNodeBuilder(),
                     NullType::class => new NullNodeBuilder(),
                     ObjectType::class => new ObjectNodeBuilder(
                         $this->get(ClassDefinitionRepository::class),
                         $this->get(ObjectBuilderFactory::class),
                         $this->get(FilteredObjectNodeBuilder::class),
-                        $settings->enableFlexibleCasting,
                     ),
                 ]);
 
@@ -131,8 +132,6 @@ public function __construct(Settings $settings)
                         $this->get(FunctionDefinitionRepository::class),
                         $settings->customConstructors
                     ),
-                    $settings->enableFlexibleCasting,
-                    $settings->allowSuperfluousKeys,
                 );
 
                 $builder = new CasterProxyNodeBuilder($builder);
@@ -148,12 +147,12 @@ public function __construct(Settings $settings)
                     );
                 }
 
-                $builder = new StrictNodeBuilder($builder, $settings->allowPermissiveTypes, $settings->enableFlexibleCasting);
+                $builder = new StrictNodeBuilder($builder);
 
                 return new ErrorCatcherNodeBuilder($builder, $settings->exceptionFilter);
             },
 
-            FilteredObjectNodeBuilder::class => fn () => new FilteredObjectNodeBuilder($settings->allowSuperfluousKeys),
+            FilteredObjectNodeBuilder::class => fn () => new FilteredObjectNodeBuilder(),
 
             ObjectImplementations::class => fn () => new ObjectImplementations(
                 new FunctionsContainer(

src/Mapper/Object/ArgumentsValues.php

@@ -5,12 +5,12 @@
 namespace CuyZ\Valinor\Mapper\Object;
 
 use CuyZ\Valinor\Mapper\Object\Exception\InvalidSource;
+use CuyZ\Valinor\Mapper\Tree\Shell;
 use CuyZ\Valinor\Type\CompositeTraversableType;
 use CuyZ\Valinor\Type\Types\ArrayKeyType;
 use IteratorAggregate;
 use Traversable;
 
-use function array_filter;
 use function array_key_exists;
 use function count;
 use function is_array;
@@ -36,22 +36,22 @@ private function __construct(Arguments $arguments)
         $this->arguments = $arguments;
     }
 
-    public static function forInterface(Arguments $arguments, mixed $value, bool $allowSuperfluousKeys): self
+    public static function forInterface(Arguments $arguments, Shell $shell): self
     {
         $self = new self($arguments);
         $self->forInterface = true;
 
         if (count($arguments) > 0) {
-            $self = $self->transform($value, $allowSuperfluousKeys);
+            $self = $self->transform($shell);
         }
 
         return $self;
     }
 
-    public static function forClass(Arguments $arguments, mixed $value, bool $allowSuperfluousKeys): self
+    public static function forClass(Arguments $arguments, Shell $shell): self
     {
         $self = new self($arguments);
-        $self = $self->transform($value, $allowSuperfluousKeys);
+        $self = $self->transform($shell);
 
         return $self;
     }
@@ -66,33 +66,22 @@ public function getValue(string $name): mixed
         return $this->value[$name];
     }
 
-    /**
-     * @return array<string>
-     */
-    public function superfluousKeys(): array
-    {
-        return array_filter(
-            array_keys($this->value),
-            fn ($key) => ! $this->arguments->has((string)$key)
-        );
-    }
-
     public function hadSingleArgument(): bool
     {
         return $this->hadSingleArgument;
     }
 
-    private function transform(mixed $value, bool $allowSuperfluousKeys): self
+    private function transform(Shell $shell): self
     {
         $clone = clone $this;
 
-        $transformedValue = $this->transformValueForSingleArgument($value, $allowSuperfluousKeys);
+        $transformedValue = $this->transformValueForSingleArgument($shell);
 
         if (! is_array($transformedValue)) {
             throw new InvalidSource($transformedValue, $this->arguments);
         }
 
-        if ($transformedValue !== $value) {
+        if ($transformedValue !== $shell->value()) {
             $clone->hadSingleArgument = true;
         }
 
@@ -109,8 +98,10 @@ private function transform(mixed $value, bool $allowSuperfluousKeys): self
         return $clone;
     }
 
-    private function transformValueForSingleArgument(mixed $value, bool $allowSuperfluousKeys): mixed
+    private function transformValueForSingleArgument(Shell $shell): mixed
     {
+        $value = $shell->value();
+
         if (count($this->arguments) !== 1) {
             return $value;
         }
@@ -122,7 +113,7 @@ private function transformValueForSingleArgument(mixed $value, bool $allowSuperf
             && $type->keyType() !== ArrayKeyType::integer();
 
         if (is_array($value) && array_key_exists($name, $value)) {
-            if ($this->forInterface || ! $isTraversableAndAllowsStringKeys || $allowSuperfluousKeys || count($value) === 1) {
+            if ($this->forInterface || ! $isTraversableAndAllowsStringKeys || $shell->allowSuperfluousKeys() || count($value) === 1) {
                 return $value;
             }
         }

src/Mapper/Tree/Builder/ArrayNodeBuilder.php

@@ -18,16 +18,14 @@
 /** @internal */
 final class ArrayNodeBuilder implements NodeBuilder
 {
-    public function __construct(private bool $enableFlexibleCasting) {}
-
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
         $type = $shell->type();
         $value = $shell->value();
 
         assert($type instanceof ArrayType || $type instanceof NonEmptyArrayType || $type instanceof IterableType);
 
-        if ($this->enableFlexibleCasting && $value === null) {
+        if ($shell->enableFlexibleCasting() && $value === null) {
             return TreeNode::branch($shell, [], []);
         }
 

src/Mapper/Tree/Builder/FilteredObjectNodeBuilder.php

@@ -6,33 +6,22 @@
 
 use CuyZ\Valinor\Mapper\Object\ArgumentsValues;
 use CuyZ\Valinor\Mapper\Object\ObjectBuilder;
-use CuyZ\Valinor\Mapper\Tree\Exception\UnexpectedArrayKeysForClass;
 use CuyZ\Valinor\Mapper\Tree\Shell;
 
-use function count;
-
 /** @internal */
 final class FilteredObjectNodeBuilder
 {
-    public function __construct(private bool $allowSuperfluousKeys) {}
-
     public function build(ObjectBuilder $builder, Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
-        $arguments = ArgumentsValues::forClass($builder->describeArguments(), $shell->value(), $this->allowSuperfluousKeys);
+        $arguments = ArgumentsValues::forClass($builder->describeArguments(), $shell);
 
         $children = $this->children($shell, $arguments, $rootBuilder);
 
         $object = $this->buildObject($builder, $children);
 
-        $node = $arguments->hadSingleArgument()
+        return $arguments->hadSingleArgument()
             ? TreeNode::flattenedBranch($shell, $object, $children[0])
             : TreeNode::branch($shell, $object, $children);
-
-        if (! $this->allowSuperfluousKeys && count($arguments->superfluousKeys()) > 0) {
-            $node = $node->withMessage(new UnexpectedArrayKeysForClass($arguments));
-        }
-
-        return $node;
     }
 
     /**

src/Mapper/Tree/Builder/InterfaceNodeBuilder.php

@@ -30,8 +30,6 @@ public function __construct(
         private ObjectBuilderFactory $objectBuilderFactory,
         private FilteredObjectNodeBuilder $filteredObjectNodeBuilder,
         private FunctionsContainer $constructors,
-        private bool $enableFlexibleCasting,
-        private bool $allowSuperfluousKeys,
     ) {}
 
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
@@ -50,7 +48,7 @@ public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
             return $this->delegate->build($shell, $rootBuilder);
         }
 
-        if ($this->enableFlexibleCasting && $shell->value() === null) {
+        if ($shell->enableFlexibleCasting() && $shell->value() === null) {
             $shell = $shell->withValue([]);
         }
 
@@ -140,7 +138,7 @@ private function transformSourceForClass(Shell $shell, Arguments $interfaceArgum
      */
     private function children(Shell $shell, Arguments $arguments, RootNodeBuilder $rootBuilder): array
     {
-        $arguments = ArgumentsValues::forInterface($arguments, $shell->value(), $this->allowSuperfluousKeys);
+        $arguments = ArgumentsValues::forInterface($arguments, $shell);
 
         $children = [];
 

src/Mapper/Tree/Builder/ListNodeBuilder.php

@@ -17,16 +17,14 @@
 /** @internal */
 final class ListNodeBuilder implements NodeBuilder
 {
-    public function __construct(private bool $enableFlexibleCasting) {}
-
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
         $type = $shell->type();
         $value = $shell->value();
 
         assert($type instanceof ListType || $type instanceof NonEmptyListType);
 
-        if ($this->enableFlexibleCasting && $value === null) {
+        if ($shell->enableFlexibleCasting() && $value === null) {
             return TreeNode::branch($shell, [], []);
         }
 
@@ -53,7 +51,7 @@ private function children(CompositeTraversableType $type, Shell $shell, RootNode
         $children = [];
 
         foreach ($values as $key => $value) {
-            if ($this->enableFlexibleCasting || $key === $expected) {
+            if ($shell->enableFlexibleCasting() || $key === $expected) {
                 $child = $shell->child((string)$expected, $subType);
                 $children[$expected] = $rootBuilder->build($child->withValue($value));
             } else {

src/Mapper/Tree/Builder/ObjectNodeBuilder.php

@@ -20,7 +20,6 @@ public function __construct(
         private ClassDefinitionRepository $classDefinitionRepository,
         private ObjectBuilderFactory $objectBuilderFactory,
         private FilteredObjectNodeBuilder $filteredObjectNodeBuilder,
-        private bool $enableFlexibleCasting,
     ) {}
 
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
@@ -30,7 +29,7 @@ public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
         // @infection-ignore-all
         assert($type instanceof ObjectType);
 
-        if ($this->enableFlexibleCasting && $shell->value() === null) {
+        if ($shell->enableFlexibleCasting() && $shell->value() === null) {
             $shell = $shell->withValue([]);
         }
 

src/Mapper/Tree/Builder/ScalarNodeBuilder.php

@@ -12,16 +12,14 @@
 /** @internal */
 final class ScalarNodeBuilder implements NodeBuilder
 {
-    public function __construct(private bool $enableFlexibleCasting) {}
-
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
         $type = $shell->type();
         $value = $shell->value();
 
         assert($type instanceof ScalarType);
 
-        if (! $this->enableFlexibleCasting || ! $type->canCast($value)) {
+        if (! $shell->enableFlexibleCasting() || ! $type->canCast($value)) {
             throw $type->errorMessage();
         }
 

src/Mapper/Tree/Builder/ShapedArrayNodeBuilder.php

@@ -5,20 +5,16 @@
 namespace CuyZ\Valinor\Mapper\Tree\Builder;
 
 use CuyZ\Valinor\Mapper\Tree\Exception\SourceMustBeIterable;
-use CuyZ\Valinor\Mapper\Tree\Exception\UnexpectedShapedArrayKeys;
 use CuyZ\Valinor\Mapper\Tree\Shell;
 use CuyZ\Valinor\Type\Types\ShapedArrayType;
 
 use function array_key_exists;
 use function assert;
-use function count;
 use function is_array;
 
 /** @internal */
 final class ShapedArrayNodeBuilder implements NodeBuilder
 {
-    public function __construct(private bool $allowSuperfluousKeys) {}
-
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
         $type = $shell->type();
@@ -34,13 +30,7 @@ public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
 
         $array = $this->buildArray($children);
 
-        $node = TreeNode::branch($shell, $array, $children);
-
-        if (! $this->allowSuperfluousKeys && count($value) > count($children)) {
-            $node = $node->withMessage(new UnexpectedShapedArrayKeys($value, $children));
-        }
-
-        return $node;
+        return TreeNode::branch($shell, $array, $children);
     }
 
     /**

src/Mapper/Tree/Builder/StrictNodeBuilder.php

@@ -13,20 +13,18 @@ final class StrictNodeBuilder implements NodeBuilder
 {
     public function __construct(
         private NodeBuilder $delegate,
-        private bool $allowPermissiveTypes,
-        private bool $enableFlexibleCasting
     ) {}
 
     public function build(Shell $shell, RootNodeBuilder $rootBuilder): TreeNode
     {
         $type = $shell->type();
 
-        if (! $this->allowPermissiveTypes) {
+        if (! $shell->allowPermissiveTypes()) {
             TypeHelper::checkPermissiveType($type);
         }
 
         if (! $shell->hasValue()) {
-            if ($this->enableFlexibleCasting) {
+            if ($shell->enableFlexibleCasting()) {
                 return $this->delegate->build($shell->withValue(null), $rootBuilder);
             }