Add support for specialized flattenedProperties in schema format

src/data/bedrock/block/upgrade/BlockStateUpgradeSchema.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\data\bedrock\block\upgrade;
 
+use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaFlattenInfo as FlattenInfo;
 use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaValueRemap as ValueRemap;
 use pocketmine\nbt\tag\Tag;
 use function count;
@@ -58,6 +59,12 @@ final class BlockStateUpgradeSchema{
 	 */
 	public array $remappedPropertyValues = [];
 
+	/**
+	 * @var FlattenInfo[]
+	 * @phpstan-var array<string, FlattenInfo>
+	 */
+	public array $flattenedProperties = [];
+
 	/**
 	 * @var BlockStateUpgradeSchemaBlockRemap[][]
 	 * @phpstan-var array<string, list<BlockStateUpgradeSchemaBlockRemap>>
@@ -93,6 +100,7 @@ final class BlockStateUpgradeSchema{
 			$this->removedProperties,
 			$this->renamedProperties,
 			$this->remappedPropertyValues,
+			$this->flattenedProperties,
 			$this->remappedStates,
 		] as $list){
 			if(count($list) !== 0){

src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaBlockRemap.php

@@ -40,7 +40,7 @@ final class BlockStateUpgradeSchemaBlockRemap{
 	 */
 	public function __construct(
 		public array $oldState,
-		public string|BlockStateUpgradeSchemaFlattenedName $newName,
+		public string|BlockStateUpgradeSchemaFlattenInfo $newName,
 		public array $newState,
 		public array $copiedState
 	){}
@@ -48,8 +48,8 @@ final class BlockStateUpgradeSchemaBlockRemap{
 	public function equals(self $that) : bool{
 		$sameName = $this->newName === $that->newName ||
 			(
-				$this->newName instanceof BlockStateUpgradeSchemaFlattenedName &&
-				$that->newName instanceof BlockStateUpgradeSchemaFlattenedName &&
+				$this->newName instanceof BlockStateUpgradeSchemaFlattenInfo &&
+				$that->newName instanceof BlockStateUpgradeSchemaFlattenInfo &&
 				$this->newName->equals($that->newName)
 			);
 		if(!$sameName){

src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaFlattenInfo.php

@@ -29,7 +29,7 @@ use pocketmine\nbt\tag\StringTag;
 use function ksort;
 use const SORT_STRING;
 
-final class BlockStateUpgradeSchemaFlattenedName{
+final class BlockStateUpgradeSchemaFlattenInfo{
 
 	/**
 	 * @param string[] $flattenedValueRemaps

src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaUtils.php

@@ -25,7 +25,7 @@ namespace pocketmine\data\bedrock\block\upgrade;
 
 use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModel;
 use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelBlockRemap;
-use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelFlattenedName;
+use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelFlattenInfo;
 use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelTag;
 use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelValueRemap;
 use pocketmine\nbt\tag\ByteTag;
@@ -155,24 +155,17 @@ final class BlockStateUpgradeSchemaUtils{
 			}
 		}
 
+		foreach(Utils::stringifyKeys($model->flattenedProperties ?? []) as $blockName => $flattenRule){
+			$result->flattenedProperties[$blockName] = self::jsonModelToFlattenRule($flattenRule);
+		}
+
 		foreach(Utils::stringifyKeys($model->remappedStates ?? []) as $oldBlockName => $remaps){
 			foreach($remaps as $remap){
 				if(isset($remap->newName)){
 					$remapName = $remap->newName;
 				}elseif(isset($remap->newFlattenedName)){
 					$flattenRule = $remap->newFlattenedName;
-					$remapName = new BlockStateUpgradeSchemaFlattenedName(
-						$flattenRule->prefix,
-						$flattenRule->flattenedProperty,
-						$flattenRule->suffix,
-						$flattenRule->flattenedValueRemaps ?? [],
-						match($flattenRule->flattenedPropertyType){
-							"string", null => StringTag::class,
-							"int" => IntTag::class,
-							"byte" => ByteTag::class,
-							default => throw new \UnexpectedValueException("Unexpected flattened property type $flattenRule->flattenedPropertyType, expected 'string', 'int' or 'byte'")
-						}
-					);
+					$remapName = self::jsonModelToFlattenRule($flattenRule);
 				}else{
 					throw new \UnexpectedValueException("Expected exactly one of 'newName' or 'newFlattenedName' properties to be set");
 				}
@@ -265,6 +258,36 @@ final class BlockStateUpgradeSchemaUtils{
 		$model->remappedPropertyValues = $modelDedupMapping;
 	}
 
+	private static function flattenRuleToJsonModel(BlockStateUpgradeSchemaFlattenInfo $flattenRule) : BlockStateUpgradeSchemaModelFlattenInfo{
+		return new BlockStateUpgradeSchemaModelFlattenInfo(
+			$flattenRule->prefix,
+			$flattenRule->flattenedProperty,
+			$flattenRule->suffix,
+			$flattenRule->flattenedValueRemaps,
+			match($flattenRule->flattenedPropertyType){
+				StringTag::class => null, //omit for TAG_String, as this is the common case
+				ByteTag::class => "byte",
+				IntTag::class => "int",
+				default => throw new \LogicException("Unexpected tag type " . $flattenRule->flattenedPropertyType . " in flattened property type")
+			}
+		);
+	}
+
+	private static function jsonModelToFlattenRule(BlockStateUpgradeSchemaModelFlattenInfo $flattenRule) : BlockStateUpgradeSchemaFlattenInfo{
+		return new BlockStateUpgradeSchemaFlattenInfo(
+			$flattenRule->prefix,
+			$flattenRule->flattenedProperty,
+			$flattenRule->suffix,
+			$flattenRule->flattenedValueRemaps ?? [],
+			match ($flattenRule->flattenedPropertyType) {
+				"string", null => StringTag::class,
+				"int" => IntTag::class,
+				"byte" => ByteTag::class,
+				default => throw new \UnexpectedValueException("Unexpected flattened property type $flattenRule->flattenedPropertyType, expected 'string', 'int' or 'byte'")
+			}
+		);
+	}
+
 	public static function toJsonModel(BlockStateUpgradeSchema $schema) : BlockStateUpgradeSchemaModel{
 		$result = new BlockStateUpgradeSchemaModel();
 		$result->maxVersionMajor = $schema->maxVersionMajor;
@@ -303,25 +326,19 @@ final class BlockStateUpgradeSchemaUtils{
 
 		self::buildRemappedValuesIndex($schema, $result);
 
+		foreach(Utils::stringifyKeys($schema->flattenedProperties) as $blockName => $flattenRule){
+			$result->flattenedProperties[$blockName] = self::flattenRuleToJsonModel($flattenRule);
+		}
+		if(isset($result->flattenedProperties)){
+			ksort($result->flattenedProperties);
+		}
+
 		foreach(Utils::stringifyKeys($schema->remappedStates) as $oldBlockName => $remaps){
 			$keyedRemaps = [];
 			foreach($remaps as $remap){
 				$modelRemap = new BlockStateUpgradeSchemaModelBlockRemap(
 					array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->oldState),
-					is_string($remap->newName) ?
-						$remap->newName :
-						new BlockStateUpgradeSchemaModelFlattenedName(
-							$remap->newName->prefix,
-							$remap->newName->flattenedProperty,
-							$remap->newName->suffix,
-							$remap->newName->flattenedValueRemaps,
-							match($remap->newName->flattenedPropertyType){
-								StringTag::class => null, //omit for TAG_String, as this is the common case
-								ByteTag::class => "byte",
-								IntTag::class => "int",
-								default => throw new \LogicException("Unexpected tag type " . $remap->newName->flattenedPropertyType . " in flattened property type")
-							}
-						),
+					is_string($remap->newName) ? $remap->newName : self::flattenRuleToJsonModel($remap->newName),
 					array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->newState),
 					$remap->copiedState
 				);

src/data/bedrock/block/upgrade/BlockStateUpgrader.php

@@ -110,10 +110,21 @@ final class BlockStateUpgrader{
 		}
 
 		$oldName = $blockStateData->getName();
-		$newName = $schema->renamedIds[$oldName] ?? null;
+		$states = $blockStateData->getStates();
+
+		if(isset($schema->renamedIds[$oldName]) && isset($schema->flattenedProperties[$oldName])){
+			//TODO: this probably ought to be validated when the schema is constructed
+			throw new AssumptionFailedError("Both renamedIds and flattenedProperties are set for the same block ID \"$oldName\" - don't know what to do");
+		}
+		if(isset($schema->renamedIds[$oldName])){
+			$newName = $schema->renamedIds[$oldName] ?? null;
+		}elseif(isset($schema->flattenedProperties[$oldName])){
+			[$newName, $states] = $this->applyPropertyFlattened($schema->flattenedProperties[$oldName], $oldName, $states);
+		}else{
+			$newName = null;
+		}
 
 		$stateChanges = 0;
-		$states = $blockStateData->getStates();
 
 		$states = $this->applyPropertyAdded($schema, $oldName, $states, $stateChanges);
 		$states = $this->applyPropertyRemoved($schema, $oldName, $states, $stateChanges);
@@ -146,22 +157,9 @@ final class BlockStateUpgrader{
 				if(is_string($remap->newName)){
 					$newName = $remap->newName;
 				}else{
-					$flattenedValue = $oldState[$remap->newName->flattenedProperty] ?? null;
-					$expectedType = $remap->newName->flattenedPropertyType;
-					if(!$flattenedValue instanceof $expectedType){
-						//flattened property is not of the expected type, so this transformation is not applicable
-						continue;
-					}
-					$embedKey = match(get_class($flattenedValue)){
-						StringTag::class => $flattenedValue->getValue(),
-						ByteTag::class => (string) $flattenedValue->getValue(),
-						IntTag::class => (string) $flattenedValue->getValue(),
-						//flattenedPropertyType is always one of these three types, but PHPStan doesn't know that
-						default => throw new AssumptionFailedError("flattenedPropertyType should be one of these three types, but have " . get_class($flattenedValue)),
-					};
-					$embedValue = $remap->newName->flattenedValueRemaps[$embedKey] ?? $embedKey;
-					$newName = sprintf("%s%s%s", $remap->newName->prefix, $embedValue, $remap->newName->suffix);
-					unset($oldState[$remap->newName->flattenedProperty]);
+					//yes, overwriting $oldState here is intentional, although we probably don't actually need it anyway
+					//it shouldn't make any difference unless the flattened property appears in copiedState for some reason
+					[$newName, $oldState] = $this->applyPropertyFlattened($remap->newName, $oldName, $oldState);
 				}
 
 				$newState = $remap->newState;
@@ -279,4 +277,32 @@ final class BlockStateUpgrader{
 
 		return $states;
 	}
+
+	/**
+	 * @param Tag[] $states
+	 * @phpstan-param array<string, Tag> $states
+	 *
+	 * @return (string|Tag[])[]
+	 * @phpstan-return array{0: string, 1: array<string, Tag>}
+	 */
+	private function applyPropertyFlattened(BlockStateUpgradeSchemaFlattenInfo $flattenInfo, string $oldName, array $states) : array{
+		$flattenedValue = $states[$flattenInfo->flattenedProperty] ?? null;
+		$expectedType = $flattenInfo->flattenedPropertyType;
+		if(!$flattenedValue instanceof $expectedType){
+			//flattened property is not of the expected type, so this transformation is not applicable
+			return [$oldName, $states];
+		}
+		$embedKey = match(get_class($flattenedValue)){
+			StringTag::class => $flattenedValue->getValue(),
+			ByteTag::class => (string) $flattenedValue->getValue(),
+			IntTag::class => (string) $flattenedValue->getValue(),
+			//flattenedPropertyType is always one of these three types, but PHPStan doesn't know that
+			default => throw new AssumptionFailedError("flattenedPropertyType should be one of these three types, but have " . get_class($flattenedValue)),
+		};
+		$embedValue = $flattenInfo->flattenedValueRemaps[$embedKey] ?? $embedKey;
+		$newName = sprintf("%s%s%s", $flattenInfo->prefix, $embedValue, $flattenInfo->suffix);
+		unset($states[$flattenInfo->flattenedProperty]);
+
+		return [$newName, $states];
+	}
 }

src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModel.php

@@ -75,6 +75,12 @@ final class BlockStateUpgradeSchemaModel implements \JsonSerializable{
 	 */
 	public array $remappedPropertyValuesIndex;
 
+	/**
+	 * @var BlockStateUpgradeSchemaModelFlattenInfo[]
+	 * @phpstan-var array<string, BlockStateUpgradeSchemaModelFlattenInfo>
+	 */
+	public array $flattenedProperties;
+
 	/**
 	 * @var BlockStateUpgradeSchemaModelBlockRemap[][]
 	 * @phpstan-var array<string, list<BlockStateUpgradeSchemaModelBlockRemap>>

src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelBlockRemap.php

@@ -43,7 +43,7 @@ final class BlockStateUpgradeSchemaModelBlockRemap{
 	 * Either this or newName must be present
 	 * Due to technical limitations of jsonmapper, we can't use a union type here
 	 */
-	public BlockStateUpgradeSchemaModelFlattenedName $newFlattenedName;
+	public BlockStateUpgradeSchemaModelFlattenInfo $newFlattenedName;
 
 	/**
 	 * @var BlockStateUpgradeSchemaModelTag[]|null
@@ -67,9 +67,9 @@ final class BlockStateUpgradeSchemaModelBlockRemap{
 	 * @phpstan-param array<string, BlockStateUpgradeSchemaModelTag> $newState
 	 * @phpstan-param list<string> $copiedState
 	 */
-	public function __construct(array $oldState, string|BlockStateUpgradeSchemaModelFlattenedName $newNameRule, array $newState, array $copiedState){
+	public function __construct(array $oldState, string|BlockStateUpgradeSchemaModelFlattenInfo $newNameRule, array $newState, array $copiedState){
 		$this->oldState = count($oldState) === 0 ? null : $oldState;
-		if($newNameRule instanceof BlockStateUpgradeSchemaModelFlattenedName){
+		if($newNameRule instanceof BlockStateUpgradeSchemaModelFlattenInfo){
 			$this->newFlattenedName = $newNameRule;
 		}else{
 			$this->newName = $newNameRule;

src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelFlattenInfo.php

@@ -25,7 +25,7 @@ namespace pocketmine\data\bedrock\block\upgrade\model;
 
 use function count;
 
-final class BlockStateUpgradeSchemaModelFlattenedName implements \JsonSerializable{
+final class BlockStateUpgradeSchemaModelFlattenInfo implements \JsonSerializable{
 
 	/** @required */
 	public string $prefix;