Optimize empty compound/list

Author: octylFractal

dfu/src/main/java/org/enginehub/linbus/dfu/LinOps.java

@@ -86,7 +86,7 @@ public LinTag<?> emptyList() {
 
     @Override
     public LinTag<?> emptyMap() {
-        return LinCompoundTag.builder().build();
+        return LinCompoundTag.empty();
     }
 
     @Override

tree/src/main/java/org/enginehub/linbus/tree/LinCompoundTag.java

@@ -54,9 +54,21 @@ public final class LinCompoundTag extends LinTag<Map<String, ? extends LinTag<?>
      * @return the tag
      */
     public static LinCompoundTag of(Map<String, ? extends LinTag<?>> value) {
+        if (value.isEmpty()) {
+            return EMPTY;
+        }
         return new LinCompoundTag(copyImmutable(value), true);
     }
 
+    private static final LinCompoundTag EMPTY = new LinCompoundTag(Map.of(), false);
+
+    /**
+     * {@return an empty compound tag}
+     */
+    public static LinCompoundTag empty() {
+        return EMPTY;
+    }
+
     /**
      * Creates a new builder.
      *
@@ -257,6 +269,9 @@ public Builder putString(String name, String value) {
          * @return the built tag
          */
         public LinCompoundTag build() {
+            if (this.collector.isEmpty()) {
+                return EMPTY;
+            }
             return new LinCompoundTag(copyImmutable(this.collector), false);
         }
     }

tree/src/main/java/org/enginehub/linbus/tree/LinListTag.java

@@ -18,13 +18,16 @@
 
 package org.enginehub.linbus.tree;
 
+import org.enginehub.linbus.common.LinTagId;
 import org.enginehub.linbus.stream.LinStream;
 import org.enginehub.linbus.stream.internal.FlatteningLinStream;
 import org.enginehub.linbus.stream.internal.SurroundingLinStream;
 import org.enginehub.linbus.stream.token.LinToken;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
@@ -51,6 +54,9 @@ public final class LinListTag<T extends LinTag<?>> extends LinTag<List<T>> {
     public static <T extends LinTag<?>> LinListTag<T> of(
         LinTagType<T> elementType, List<T> value
     ) {
+        if (value.isEmpty()) {
+            return empty(elementType);
+        }
         for (T t : value) {
             if (t.type() != elementType) {
                 throw new IllegalArgumentException("Element is not of type " + elementType.name() + " but "
@@ -60,6 +66,11 @@ public static <T extends LinTag<?>> LinListTag<T> of(
         return new LinListTag<>(elementType, List.copyOf(value));
     }
 
+    private static final List<LinListTag<?>> EMPTY_LISTS = Arrays.stream(LinTagId.values())
+        .sorted(Comparator.comparingInt(LinTagId::id))
+        .<LinListTag<?>>map(id -> new LinListTag<>(LinTagType.fromId(id), List.of()))
+        .toList();
+
     /**
      * Get an empty list of the given element type.
      *
@@ -68,7 +79,9 @@ public static <T extends LinTag<?>> LinListTag<T> of(
      * @return an empty list
      */
     public static <T extends LinTag<?>> LinListTag<T> empty(LinTagType<T> elementType) {
-        return builder(elementType).build();
+        @SuppressWarnings("unchecked")
+        LinListTag<T> empty = (LinListTag<T>) EMPTY_LISTS.get(elementType.id().id());
+        return empty;
     }
 
     /**
@@ -169,6 +182,9 @@ public Builder<T> set(int index, T tag) {
          * @return the built tag
          */
         public LinListTag<T> build() {
+            if (this.collector.isEmpty()) {
+                return empty(this.elementType);
+            }
             return new LinListTag<>(this.elementType, List.copyOf(this.collector));
         }
     }

tree/src/test/java/org/enginehub/linbus/tree/LinCompoundTagTest.java

@@ -50,6 +50,22 @@ void roundTripBuilder() {
         assertThat(initial).isEqualTo(initial.toBuilder().build());
     }
 
+    @Test
+    void emptyImplementation() {
+        assertThat(LinCompoundTag.empty()).compoundValue().isEmpty();
+        assertThat(LinCompoundTag.empty()).isSameInstanceAs(LinCompoundTag.empty());
+    }
+
+    @Test
+    void builderReturnsEmptySingleton() {
+        assertThat(LinCompoundTag.builder().build()).isSameInstanceAs(LinCompoundTag.empty());
+    }
+
+    @Test
+    void ofEmptyReturnsEmptySingleton() {
+        assertThat(LinCompoundTag.of(Map.of())).isSameInstanceAs(LinCompoundTag.empty());
+    }
+
     @Test
     void builderRemove() {
         var initial = LinCompoundTag.of(Map.of(

tree/src/test/java/org/enginehub/linbus/tree/LinListTagTest.java

@@ -95,6 +95,19 @@ void emptyImplementation() {
         var empty = LinListTag.empty(LinTagType.stringTag());
         assertThat(empty).listValue().isEmpty();
         assertThat(empty.elementType()).isEqualTo(LinTagType.stringTag());
+        assertThat(empty).isSameInstanceAs(LinListTag.empty(LinTagType.stringTag()));
+    }
+
+    @Test
+    void builderReturnsEmptySingleton() {
+        assertThat(LinListTag.builder(LinTagType.stringTag()).build())
+            .isSameInstanceAs(LinListTag.empty(LinTagType.stringTag()));
+    }
+
+    @Test
+    void ofEmptyReturnsEmptySingleton() {
+        assertThat(LinListTag.of(LinTagType.stringTag(), List.of()))
+            .isSameInstanceAs(LinListTag.empty(LinTagType.stringTag()));
     }
 
     @Test