Replaces JavaSerializableCodec with DynamicCodec as the default

* Skylark serialization was previously dropping location in error, which this fixes.
* Deletes a lot of codecs with fidelity issues (DynamicCodec has full fidelity).
* Deletes EnumRuntimeCodec which can now be replaced with the superior EnumCodec.
* This should eventually allow us to delete Serializable from all Blaze. The remaining blocker is NoSuchPackageExceptionCodec.

PiperOrigin-RevId: 191603929

4 files changed, 99 insertions, 35 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainUtilTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainUtilTest.java
index 166bc220e9..7b2f76cb2c 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainUtilTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainUtilTest.java
@@ -296,12 +296,21 @@ public class ToolchainUtilTest extends ToolchainTestCase {
     }
   }
 
-  @AutoValue
-  abstract static class CreateToolchainContextValue implements SkyValue {
-    abstract ToolchainContext toolchainContext();
+  // TODO(blaze-team): implement equals and hashcode for ToolchainContext and convert this to
+  // autovalue.
+  static class CreateToolchainContextValue implements SkyValue {
+    private final ToolchainContext toolchainContext;
+
+    private CreateToolchainContextValue(ToolchainContext toolchainContext) {
+      this.toolchainContext = toolchainContext;
+    }
 
     static CreateToolchainContextValue create(ToolchainContext toolchainContext) {
-      return new AutoValue_ToolchainUtilTest_CreateToolchainContextValue(toolchainContext);
+      return new CreateToolchainContextValue(toolchainContext);
+    }
+
+    ToolchainContext toolchainContext() {
+      return toolchainContext;
     }
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecRegistryTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecRegistryTest.java
index 71efbd714b..dca168b6c6 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecRegistryTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecRegistryTest.java
@@ -39,17 +39,17 @@ public class ObjectCodecRegistryTest {
             .add(codec2)
             .build();
 
-    CodecDescriptor fooDescriptor = underTest.getCodecDescriptor(String.class);
+    CodecDescriptor fooDescriptor = underTest.getCodecDescriptorForObject("hello");
     assertThat(fooDescriptor.getCodec()).isSameAs(codec1);
     assertThat(underTest.getCodecDescriptorByTag(fooDescriptor.getTag())).isSameAs(fooDescriptor);
 
-    CodecDescriptor barDescriptor = underTest.getCodecDescriptor(Integer.class);
+    CodecDescriptor barDescriptor = underTest.getCodecDescriptorForObject(1);
     assertThat(barDescriptor.getCodec()).isSameAs(codec2);
     assertThat(underTest.getCodecDescriptorByTag(barDescriptor.getTag())).isSameAs(barDescriptor);
 
     assertThat(barDescriptor.getTag()).isNotEqualTo(fooDescriptor.getTag());
 
-    assertThrows(NoCodecException.class, () -> underTest.getCodecDescriptor(Byte.class));
+    assertThrows(NoCodecException.class, () -> underTest.getCodecDescriptorForObject((byte) 1));
     assertThrows(NoCodecException.class, () -> underTest.getCodecDescriptorByTag(42));
   }
 
@@ -58,18 +58,24 @@ public class ObjectCodecRegistryTest {
     SingletonCodec<String> codec = SingletonCodec.of("value1", "mnemonic1");
 
     ObjectCodecRegistry underTest =
-        ObjectCodecRegistry.newBuilder().setAllowDefaultCodec(true).add(codec).build();
+        ObjectCodecRegistry.newBuilder()
+            .setAllowDefaultCodec(true)
+            .add(codec)
+            .addClassName(Byte.class.getName())
+            .addClassName(Integer.class.getName())
+            .build();
 
-    CodecDescriptor fooDescriptor = underTest.getCodecDescriptor(String.class);
+    CodecDescriptor fooDescriptor = underTest.getCodecDescriptorForObject("value1");
     assertThat(fooDescriptor.getCodec()).isSameAs(codec);
 
-    CodecDescriptor barDefaultDescriptor = underTest.getCodecDescriptor(Integer.class);
+    CodecDescriptor barDefaultDescriptor = underTest.getCodecDescriptorForObject(15);
     assertThat(barDefaultDescriptor.getCodec()).isNotSameAs(codec);
     assertThat(barDefaultDescriptor.getTag()).isNotEqualTo(fooDescriptor.getTag());
     assertThat(underTest.getCodecDescriptorByTag(barDefaultDescriptor.getTag()))
         .isSameAs(barDefaultDescriptor);
 
-    assertThat(underTest.getCodecDescriptor(Byte.class)).isSameAs(barDefaultDescriptor);
+    assertThat(underTest.getCodecDescriptorForObject((byte) 9).getCodec().getClass())
+        .isSameAs(barDefaultDescriptor.getCodec().getClass());
 
     // Bogus tags still throw.
     assertThrows(NoCodecException.class, () -> underTest.getCodecDescriptorByTag(42));
@@ -81,18 +87,28 @@ public class ObjectCodecRegistryTest {
     SingletonCodec<Integer> codec2 = SingletonCodec.of(1, "mnemonic2");
 
     ObjectCodecRegistry underTest1 =
-        ObjectCodecRegistry.newBuilder().setAllowDefaultCodec(true).add(codec1).add(codec2).build();
+        ObjectCodecRegistry.newBuilder()
+            .setAllowDefaultCodec(true)
+            .add(codec1)
+            .add(codec2)
+            .addClassName(Byte.class.getName())
+            .build();
 
     ObjectCodecRegistry underTest2 =
-        ObjectCodecRegistry.newBuilder().setAllowDefaultCodec(true).add(codec2).add(codec1).build();
+        ObjectCodecRegistry.newBuilder()
+            .setAllowDefaultCodec(true)
+            .add(codec2)
+            .add(codec1)
+            .addClassName(Byte.class.getName())
+            .build();
 
-    assertThat(underTest1.getCodecDescriptor(String.class).getTag())
-        .isEqualTo(underTest2.getCodecDescriptor(String.class).getTag());
-    assertThat(underTest1.getCodecDescriptor(Integer.class).getTag())
-        .isEqualTo(underTest2.getCodecDescriptor(Integer.class).getTag());
+    assertThat(underTest1.getCodecDescriptorForObject("value1").getTag())
+        .isEqualTo(underTest2.getCodecDescriptorForObject("value1").getTag());
+    assertThat(underTest1.getCodecDescriptorForObject(5).getTag())
+        .isEqualTo(underTest2.getCodecDescriptorForObject(5).getTag());
     // Default codec.
-    assertThat(underTest1.getCodecDescriptor(Byte.class).getTag())
-        .isEqualTo(underTest2.getCodecDescriptor(Byte.class).getTag());
+    assertThat(underTest1.getCodecDescriptorForObject((byte) 10).getTag())
+        .isEqualTo(underTest2.getCodecDescriptorForObject((byte) 10).getTag());
   }
 
   @Test
@@ -133,9 +149,55 @@ public class ObjectCodecRegistryTest {
             .build();
 
     ObjectCodecRegistry copy = underTest.getBuilder().build();
-    assertThat(copy.getCodecDescriptor(Integer.class).getTag()).isEqualTo(1);
-    assertThat(copy.getCodecDescriptor(String.class).getTag()).isEqualTo(2);
+    assertThat(copy.getCodecDescriptorForObject(12).getTag()).isEqualTo(1);
+    assertThat(copy.getCodecDescriptorForObject("value1").getTag()).isEqualTo(2);
     assertThat(copy.maybeGetTagForConstant(constant)).isNotNull();
-    assertThrows(NoCodecException.class, () -> copy.getCodecDescriptor(Byte.class));
+    assertThrows(NoCodecException.class, () -> copy.getCodecDescriptorForObject((byte) 5));
+  }
+
+  private enum TestEnum {
+    ONE {
+      @Override
+      public int val() {
+        return 1;
+      }
+    },
+    TWO {
+      @Override
+      public int val() {
+        return 2;
+      }
+    },
+    THREE {
+      @Override
+      public int val() {
+        return 3;
+      }
+    };
+
+    public abstract int val();
+  }
+
+  @SuppressWarnings("GetClassOnEnum")
+  @Test
+  public void testDefaultEnum() throws NoCodecException {
+    assertThat(TestEnum.ONE.getClass()).isNotEqualTo(TestEnum.class);
+    assertThat(TestEnum.ONE.getDeclaringClass()).isEqualTo(TestEnum.class);
+    assertThat(TestEnum.ONE.getClass()).isNotEqualTo(TestEnum.TWO.getClass());
+
+    ObjectCodecRegistry underTest =
+        ObjectCodecRegistry.newBuilder()
+            .setAllowDefaultCodec(true)
+            .addClassName(TestEnum.class.getName())
+            .addClassName(TestEnum.ONE.getClass().getName())
+            .addClassName(TestEnum.TWO.getClass().getName())
+            .addClassName(TestEnum.THREE.getClass().getName())
+            .build();
+
+    CodecDescriptor oneDescriptor = underTest.getCodecDescriptorForObject(TestEnum.ONE);
+    CodecDescriptor twoDescriptor = underTest.getCodecDescriptorForObject(TestEnum.TWO);
+    assertThat(oneDescriptor).isEqualTo(twoDescriptor);
+
+    assertThat(oneDescriptor.getCodec().getEncodedClass()).isEqualTo(TestEnum.class);
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecsTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecsTest.java
index 66ad1db474..6bfbcec540 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/ObjectCodecsTest.java
@@ -30,7 +30,6 @@ import com.google.protobuf.ByteString;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import java.io.IOException;
-import java.io.NotSerializableException;
 import java.util.List;
 import org.junit.Before;
 import org.junit.Test;
@@ -174,13 +173,6 @@ public class ObjectCodecsTest {
   }
 
   @Test
-  public void testSerializePropagatesSerializationExceptionFromDefaultCodec() {
-    SerializationException exception =
-        assertThrows(SerializationException.class, () -> underTest.serialize(new Object()));
-    assertThat(exception).hasCauseThat().isInstanceOf(NotSerializableException.class);
-  }
-
-  @Test
   public void testDeserializePropagatesSerializationExceptionFromDefaultCodec() {
     ByteString serialized = ByteString.copyFromUtf8("probably not serialized anything");
 
@@ -207,7 +199,8 @@ public class ObjectCodecsTest {
         new ObjectCodecs(
             ObjectCodecRegistry.newBuilder().setAllowDefaultCodec(false).build(),
             ImmutableMap.of());
-    assertThrows(RuntimeException.class, () -> underTest.deserialize(serialized));
+    assertThrows(
+        SerializationException.NoCodecException.class, () -> underTest.deserialize(serialized));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/SerializationContextTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/SerializationContextTest.java
index 0508bb5e7d..816952c2a4 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/serialization/SerializationContextTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/serialization/SerializationContextTest.java
@@ -68,13 +68,13 @@ public class SerializationContextTest {
     when(codecDescriptor.getTag()).thenReturn(1);
     ObjectCodecRegistry registry = Mockito.mock(ObjectCodecRegistry.class);
     when(registry.maybeGetTagForConstant(Mockito.anyObject())).thenReturn(null);
-    when(registry.getCodecDescriptor(String.class)).thenReturn(codecDescriptor);
+    when(registry.getCodecDescriptorForObject("string")).thenReturn(codecDescriptor);
     CodedOutputStream codedOutputStream = Mockito.mock(CodedOutputStream.class);
     SerializationContext underTest = new SerializationContext(registry, ImmutableMap.of());
     underTest.serialize("string", codedOutputStream);
     Mockito.verify(codedOutputStream).writeSInt32NoTag(1);
     Mockito.verify(registry).maybeGetTagForConstant("string");
-    Mockito.verify(registry).getCodecDescriptor(String.class);
+    Mockito.verify(registry).getCodecDescriptorForObject("string");
     Mockito.verify(codecDescriptor).getTag();
     Mockito.verify(codecDescriptor).serialize(underTest, "string", codedOutputStream);
   }
@@ -114,14 +114,14 @@ public class SerializationContextTest {
     doReturn(codec).when(codecDescriptor).getCodec();
     ObjectCodecRegistry registry = Mockito.mock(ObjectCodecRegistry.class);
     when(registry.maybeGetTagForConstant(Mockito.anyObject())).thenReturn(null);
-    when(registry.getCodecDescriptor(String.class)).thenReturn(codecDescriptor);
+    when(registry.getCodecDescriptorForObject("string")).thenReturn(codecDescriptor);
     CodedOutputStream codedOutputStream = Mockito.mock(CodedOutputStream.class);
     SerializationContext underTest =
         new SerializationContext(registry, ImmutableMap.of()).getMemoizingContext();
     underTest.serialize("string", codedOutputStream);
     Mockito.verify(codedOutputStream).writeSInt32NoTag(1);
     Mockito.verify(registry).maybeGetTagForConstant("string");
-    Mockito.verify(registry).getCodecDescriptor(String.class);
+    Mockito.verify(registry).getCodecDescriptorForObject("string");
     Mockito.verify(codecDescriptor).getTag();
     Mockito.verify(codecDescriptor).getCodec();
     Mockito.verify(codec).serialize(underTest, "string", codedOutputStream);