Support "heterogeneous" NBT lists somehow

[SPGoding]

When heterogeneous SNBT lists are deserialized into NBT, non-compound entries (or wrapper compound entries? The logic of wrapIfNeeded() makes it seem like you could have double wrapped things if I'm not mistaken) are transformed into a wrapper compound. e.g. ['a', {'b': 3}] is stored as [{'': 'a'}, {'b': 3}].

net/minecraft/nbt/NbtOps

private static class HeterogenousListCollector implements NbtOps.ListCollector {
   private final ListTag result = new ListTag();

   public HeterogenousListCollector() {
      super();
   }

   public HeterogenousListCollector(Collection<Tag> list) {
      super();
      this.result.addAll(list);
   }

   public HeterogenousListCollector(IntArrayList list) {
      super();
      list.forEach((var1x) -> {
         this.result.add(wrapElement(IntTag.valueOf(var1x)));
      });
   }

   public HeterogenousListCollector(ByteArrayList list) {
      super();
      list.forEach((var1x) -> {
         this.result.add(wrapElement(ByteTag.valueOf(var1x)));
      });
   }

   public HeterogenousListCollector(LongArrayList list) {
      super();
      list.forEach((var1x) -> {
         this.result.add(wrapElement(LongTag.valueOf(var1x)));
      });
   }

   private static boolean isWrapper(CompoundTag compound) {
      return compound.size() == 1 && compound.contains("");
   }

   private static Tag wrapIfNeeded(Tag tag) {
      if (tag instanceof CompoundTag) {
         CompoundTag compound = (CompoundTag)tag;
         if (!isWrapper(compound)) {
            return compound;
         }
      }

      return wrapElement(tag);
   }

   private static CompoundTag wrapElement(Tag tag) {
      CompoundTag wrapper = new CompoundTag();
      wrapper.put("", tag);
      return wrapper;
   }

   public NbtOps.ListCollector accept(Tag tag) {
      this.result.add(wrapIfNeeded(tag));
      return this;
   }

   public Tag result() {
      return this.result;
   }
}

private static class HomogenousListCollector implements NbtOps.ListCollector {
   private final ListTag result = new ListTag();

   HomogenousListCollector(Tag tag) {
      super();
      this.result.add(tag);
   }

   HomogenousListCollector(ListTag list) {
      super();
      this.result.addAll(list);
   }

   public NbtOps.ListCollector accept(Tag tag) {
      if (tag.getId() != this.result.getElementType()) {
         return (new NbtOps.HeterogenousListCollector()).acceptAll(this.result).accept(tag);
      } else {
         this.result.add(tag);
         return this;
      }
   }

   public Tag result() {
      return this.result;
   }
}

Annoyingly, this transformation is not undone when NBT is serialized, so users could see those wrapper compounds in /data command output. We need to somehow support usage of wrapper compounds in commands. This was improved in 25w09a (#1771).

[misode]

Since 25w09a, I don't believe we need to change anything.

[SPGoding]

Yeah cuz you already added this

Spyglass/packages/nbt/src/parser/collection.ts

Lines 25 to 39 in b7d9e3e

	// Check if every element is of the same type.
	if (ans.valueType) {
	// TODO: don't have this inline java-edition version check
	const release = ctx.project['loadedVersion'] as string | undefined
	if (release && Number(release.slice(2)) < Number('1.21.5'.slice(2))) {
	for (const { value } of ans.children) {
	if (value && value.type !== ans.valueType) {
	ctx.err.report(
	localize('expected-got', localizeTag(ans.valueType), localizeTag(value.type)),
	value,
	)
	}
	}
	}
	}