ExportedClassConstantNode.php

<?php declare(strict_types = 1);

namespace PHPStan\Dependency\ExportedNode;

use JsonSerializable;
use PHPStan\Dependency\ExportedNode;
use PHPStan\ShouldNotHappenException;
use ReturnTypeWillChange;
use function array_map;
use function count;

class ExportedClassConstantNode implements ExportedNode, JsonSerializable
{

	/**
	 * @param ExportedAttributeNode[] $attributes
	 */
	public function __construct(
		private string $name,
		private string $value,
		private array $attributes,
	)
	{
	}

	public function equals(ExportedNode $node): bool
	{
		if (!$node instanceof self) {
			return false;
		}

		if (count($this->attributes) !== count($node->attributes)) {
			return false;
		}

		foreach ($this->attributes as $i => $ourAttribute) {
			$theirAttribute = $node->attributes[$i];
			if (!$ourAttribute->equals($theirAttribute)) {
				return false;
			}
		}

		return $this->name === $node->name
			&& $this->value === $node->value;
	}

	/**
	 * @param mixed[] $properties
	 * @return self
	 */
	public static function __set_state(array $properties): ExportedNode
	{
		return new self(
			$properties['name'],
			$properties['value'],
			$properties['attributes'],
		);
	}

	/**
	 * @param mixed[] $data
	 * @return self
	 */
	public static function decode(array $data): ExportedNode
	{
		return new self(
			$data['name'],
			$data['value'],
			array_map(static function (array $parameterData): ExportedAttributeNode {
				if ($parameterData['type'] !== ExportedAttributeNode::class) {
					throw new ShouldNotHappenException();
				}
				return ExportedAttributeNode::decode($parameterData['data']);
			}, $data['attributes']),
		);
	}

	/**
	 * @return mixed
	 */
	#[ReturnTypeWillChange]
	public function jsonSerialize()
	{
		return [
			'type' => self::class,
			'data' => [
				'name' => $this->name,
				'value' => $this->value,
				'attributes' => $this->attributes,
			],
		];
	}

}