Enable to suppress Suspicious dumping error

composer.json

@@ -18,7 +18,7 @@
 		"php": "8.1 - 8.4",
 		"ext-tokenizer": "*",
 		"ext-ctype": "*",
-		"nette/neon": "^3.3 || ^4.0",
+		"nette/neon": "^3.3.3 || ^4.0",
 		"nette/php-generator": "^4.1.6",
 		"nette/robot-loader": "^4.0",
 		"nette/schema": "^1.2.5",
@@ -39,7 +39,7 @@
 	},
 	"extra": {
 		"branch-alias": {
-			"dev-master": "3.2-dev"
+			"dev-master": "4.0-dev"
 		}
 	}
 }

src/DI/Attributes/IgnoreDumping.php

@@ -0,0 +1,17 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette\DI\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class IgnoreDumping
+{
+}

src/DI/Config/Adapter.php

@@ -20,6 +20,3 @@ interface Adapter
 	 */
 	function load(string $file): array;
 }
-
-
-class_exists(IAdapter::class);

src/DI/Config/Adapters/NeonAdapter.php

@@ -11,6 +11,7 @@
 
 use Nette;
 use Nette\DI;
+use Nette\DI\Definitions;
 use Nette\DI\Definitions\Reference;
 use Nette\DI\Definitions\Statement;
 use Nette\Neon;
@@ -24,6 +25,7 @@ final class NeonAdapter implements Nette\DI\Config\Adapter
 {
 	private const PreventMergingSuffix = '!';
 	private string $file;
+	private \WeakMap $parents;
 
 
 	/**
@@ -40,61 +42,21 @@ public function load(string $file): array
 		$decoder = new Neon\Decoder;
 		$node = $decoder->parseToNode($input);
 		$traverser = new Neon\Traverser;
-		$node = $traverser->traverse($node, $this->firstClassCallableVisitor(...));
 		$node = $traverser->traverse($node, $this->removeUnderscoreVisitor(...));
 		$node = $traverser->traverse($node, $this->convertAtSignVisitor(...));
 		$node = $traverser->traverse($node, $this->deprecatedParametersVisitor(...));
 		$node = $traverser->traverse($node, $this->resolveConstantsVisitor(...));
-		return $this->process((array) $node->toValue());
+		$node = $traverser->traverse($node, $this->preventMergingVisitor(...));
+		$this->connectParentsVisitor($traverser, $node);
+		$node = $traverser->traverse($node, leave: $this->entityToExpressionVisitor(...));
+		return (array) $node->toValue();
 	}
 
 
-	/** @throws Nette\InvalidStateException */
+	/** @deprecated */
 	public function process(array $arr): array
 	{
-		$res = [];
-		foreach ($arr as $key => $val) {
-			if (is_string($key) && str_ends_with($key, self::PreventMergingSuffix)) {
-				if (!is_array($val) && $val !== null) {
-					throw new Nette\DI\InvalidConfigurationException(sprintf(
-						"Replacing operator is available only for arrays, item '%s' is not array (used in '%s')",
-						$key,
-						$this->file,
-					));
-				}
-
-				$key = substr($key, 0, -1);
-				$val[DI\Config\Helpers::PREVENT_MERGING] = true;
-			}
-
-			if (is_array($val)) {
-				$val = $this->process($val);
-
-			} elseif ($val instanceof Neon\Entity) {
-				if ($val->value === Neon\Neon::CHAIN) {
-					$tmp = null;
-					foreach ($this->process($val->attributes) as $st) {
-						$tmp = new Statement(
-							$tmp === null ? $st->getEntity() : [$tmp, ltrim(implode('::', (array) $st->getEntity()), ':')],
-							$st->arguments,
-						);
-					}
-
-					$val = $tmp;
-				} else {
-					$tmp = $this->process([$val->value]);
-					if (is_string($tmp[0]) && str_contains($tmp[0], '?')) {
-						throw new Nette\DI\InvalidConfigurationException("Operator ? is deprecated in config file (used in '$this->file')");
-					}
-
-					$val = new Statement($tmp[0], $this->process($val->attributes));
-				}
-			}
-
-			$res[$key] = $val;
-		}
-
-		return $res;
+		return $arr;
 	}
 
 
@@ -151,16 +113,89 @@ function (&$val): void {
 	}
 
 
-	private function firstClassCallableVisitor(Node $node): void
+	private function preventMergingVisitor(Node $node): void
 	{
-		if ($node instanceof Node\EntityNode
-			&& count($node->attributes) === 1
-			&& $node->attributes[0]->key === null
-			&& $node->attributes[0]->value instanceof Node\LiteralNode
-			&& $node->attributes[0]->value->value === '...'
+		if (!$node instanceof Node\ArrayNode) {
+			return;
+		}
+
+		foreach ($node->items as $item) {
+			if (
+				$item->key instanceof Node\LiteralNode
+				&& is_string($item->key->value)
+				&& str_ends_with($item->key->value, self::PreventMergingSuffix)
+			) {
+				if ($item->value instanceof Node\LiteralNode && $item->value->value === null) {
+					$item->value = new Node\InlineArrayNode('[');
+				} elseif (!$item->value instanceof Node\ArrayNode) {
+					throw new Nette\DI\InvalidConfigurationException(sprintf(
+						"Replacing operator is available only for arrays, item '%s' is not array (used in '%s')",
+						$item->key->value,
+						$this->file,
+					));
+				}
+
+				$item->key->value = substr($item->key->value, 0, -1);
+				$item->value->items[] = $newItem = new Node\ArrayItemNode;
+				$newItem->key = new Node\LiteralNode(DI\Config\Helpers::PREVENT_MERGING);
+				$newItem->value = new Node\LiteralNode(true);
+			}
+		}
+	}
+
+
+	private function entityToExpressionVisitor(Node $node): Node
+	{
+		if ($node instanceof Node\EntityChainNode) {
+			return new Node\LiteralNode($this->buildExpression($node->chain));
+
+		} elseif (
+			$node instanceof Node\EntityNode
+			&& !$this->parents[$node] instanceof Node\EntityChainNode
 		) {
-			$node->attributes[0]->value->value = Nette\DI\Resolver::getFirstClassCallable()[0];
+			return new Node\LiteralNode($this->buildExpression([$node]));
+
+		} else {
+			return $node;
+		}
+	}
+
+
+	private function buildExpression(array $chain): Definitions\Expression
+	{
+		$node = array_pop($chain);
+		$entity = $node->toValue();
+		if (is_string($entity->value) && str_contains($entity->value, '?')) {
+			throw new Nette\DI\InvalidConfigurationException("Operator ? is deprecated in config file (used in '$this->file')");
+		}
+
+		$stmt = new Statement(
+			$chain ? [$this->buildExpression($chain), ltrim($entity->value, ':')] : $entity->value,
+			$entity->attributes,
+		);
+
+		if ($this->isFirstClassCallable($node)) {
+			$entity = $stmt->getEntity();
+			if (is_array($entity)) {
+				if ($entity[0] === '') {
+					return new Definitions\FunctionCallable($entity[1]);
+				}
+				return new Definitions\MethodCallable(...$entity);
+			} else {
+				throw new Nette\DI\InvalidConfigurationException("Cannot create closure for '$entity' in config file (used in '$this->file')");
+			}
 		}
+
+		return $stmt;
+	}
+
+
+	private function isFirstClassCallable(Node\EntityNode $node): bool
+	{
+		return array_keys($node->attributes) === [0]
+			&& $node->attributes[0]->key === null
+			&& $node->attributes[0]->value instanceof Node\LiteralNode
+			&& $node->attributes[0]->value->value === '...';
 	}
 
 
@@ -181,11 +216,6 @@ private function removeUnderscoreVisitor(Node $node): void
 			if ($attr->value instanceof Node\LiteralNode && $attr->value->value === '_') {
 				unset($node->attributes[$i]);
 				$index = true;
-
-			} elseif ($attr->value instanceof Node\LiteralNode && $attr->value->value === '...') {
-				trigger_error("Replace ... with _ in configuration file '$this->file'.", E_USER_DEPRECATED);
-				unset($node->attributes[$i]);
-				$index = true;
 			}
 		}
 	}
@@ -240,4 +270,21 @@ private function resolveConstantsVisitor(Node $node): void
 			}
 		}
 	}
+
+
+	private function connectParentsVisitor(Neon\Traverser $traverser, Node $node): void
+	{
+		$this->parents = new \WeakMap;
+		$stack = [];
+		$traverser->traverse(
+			$node,
+			enter: function (Node $node) use (&$stack) {
+				$this->parents[$node] = end($stack);
+				$stack[] = $node;
+			},
+			leave: function () use (&$stack) {
+				array_pop($stack);
+			},
+		);
+	}
 }

src/DI/ContainerBuilder.php

@@ -22,10 +22,10 @@ class ContainerBuilder
 		ThisService = 'self',
 		ThisContainer = 'container';
 
-	/** @deprecated use ContainerBuilder::ThisService */
+	#[\Deprecated('use ContainerBuilder::ThisService')]
 	public const THIS_SERVICE = self::ThisService;
 
-	/** @deprecated use ContainerBuilder::ThisContainer */
+	#[\Deprecated('use ContainerBuilder::ThisContainer')]
 	public const THIS_CONTAINER = self::ThisContainer;
 
 	public array $parameters = [];
@@ -394,8 +394,8 @@ public static function literal(string $code, ?array $args = null): Nette\PhpGene
 	public function formatPhp(string $statement, array $args): string
 	{
 		array_walk_recursive($args, function (&$val): void {
-			if ($val instanceof Nette\DI\Definitions\Statement) {
-				$val = (new Resolver($this))->completeStatement($val);
+			if ($val instanceof Nette\DI\Definitions\Expression) {
+				$val->complete(new Resolver($this));
 
 			} elseif ($val instanceof Definition) {
 				$val = new Definitions\Reference($val->getName());

src/DI/Definitions/AccessorDefinition.php

@@ -28,8 +28,8 @@ public function setImplement(string $interface): static
 	{
 		if (!interface_exists($interface)) {
 			throw new Nette\InvalidArgumentException(sprintf(
-				"Service '%s': Interface '%s' not found.",
-				$this->getName(),
+				"[%s]\nInterface '%s' not found.",
+				$this->getDescriptor(),
 				$interface,
 			));
 		}
@@ -44,19 +44,19 @@ public function setImplement(string $interface): static
 			|| count($rc->getMethods()) > 1
 		) {
 			throw new Nette\InvalidArgumentException(sprintf(
-				"Service '%s': Interface %s must have just one non-static method get().",
-				$this->getName(),
+				"[%s]\nInterface %s must have just one non-static method get().",
+				$this->getDescriptor(),
 				$interface,
 			));
 		} elseif ($method->getNumberOfParameters()) {
 			throw new Nette\InvalidArgumentException(sprintf(
-				"Service '%s': Method %s::get() must have no parameters.",
-				$this->getName(),
+				"[%s]\nMethod %s::get() must have no parameters.",
+				$this->getDescriptor(),
 				$interface,
 			));
 		}
 
-		Helpers::ensureClassType(Type::fromReflection($method), "return type of $interface::get()");
+		Helpers::ensureClassType(Type::fromReflection($method), "return type of $interface::get()", $this->getDescriptor());
 		return parent::setType($interface);
 	}
 
@@ -103,11 +103,11 @@ public function complete(Nette\DI\Resolver $resolver): void
 			$this->setReference(Type::fromReflection($method)->getSingleName());
 		}
 
-		$this->reference = $resolver->normalizeReference($this->reference);
+		$this->reference->complete($resolver);
 	}
 
 
-	public function generateMethod(Nette\PhpGenerator\Method $method, Nette\DI\PhpGenerator $generator): void
+	public function generateCode(Nette\DI\PhpGenerator $generator): string
 	{
 		$class = (new Nette\PhpGenerator\ClassType)
 			->addImplement($this->getType());
@@ -123,6 +123,6 @@ public function generateMethod(Nette\PhpGenerator\Method $method, Nette\DI\PhpGe
 			->setBody('return $this->container->getService(?);', [$this->reference->getValue()])
 			->setReturnType((string) Type::fromReflection($rm));
 
-		$method->setBody('return new class ($this) ' . $class . ';');
+		return 'return new class ($this) ' . $class . ';';
 	}
 }

src/DI/Definitions/Definition.php

@@ -46,6 +46,29 @@ final public function getName(): ?string
 	}
 
 
+	final public function isAnonymous(): bool
+	{
+		return !$this->name || ctype_digit($this->name);
+	}
+
+
+	public function getDescriptor(): string
+	{
+		if (!$this->isAnonymous()) {
+			return "Service '$this->name'" . ($this->type ? " of type $this->type" : '');
+
+		} elseif ($this->type) {
+			return "Service of type $this->type";
+
+		} elseif ($this->name) {
+			return "Service '$this->name'";
+
+		} else {
+			return 'Service ?';
+		}
+	}
+
+
 	protected function setType(?string $type): static
 	{
 		if ($this->autowired && $this->notifier && $this->type !== $type) {
@@ -56,8 +79,8 @@ protected function setType(?string $type): static
 			$this->type = null;
 		} elseif (!class_exists($type) && !interface_exists($type)) {
 			throw new Nette\InvalidArgumentException(sprintf(
-				"Service '%s': Class or interface '%s' not found.",
-				$this->name,
+				"[%s]\nClass or interface '%s' not found.",
+				$this->getDescriptor(),
 				$type,
 			));
 		} else {
@@ -147,7 +170,7 @@ abstract public function resolveType(Nette\DI\Resolver $resolver): void;
 	abstract public function complete(Nette\DI\Resolver $resolver): void;
 
 
-	abstract public function generateMethod(Nette\PhpGenerator\Method $method, Nette\DI\PhpGenerator $generator): void;
+	abstract public function generateCode(Nette\DI\PhpGenerator $generator): string;
 
 
 	final public function setNotifier(?\Closure $notifier): void