Make Artifact codecs into DeferredObjectCodecs.

This makes them async-comptiable.

PiperOrigin-RevId: 597604918
Change-Id: Ia30612832296c7790dd18b19e2da04b101d2f615

Author: aoeui

src/main/java/com/google/devtools/build/lib/actions/ArtifactCodecs.java

@@ -23,20 +23,23 @@
 import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact;
 import com.google.devtools.build.lib.actions.Artifact.SpecialArtifactType;
 import com.google.devtools.build.lib.actions.Artifact.TreeFileArtifact;
-import com.google.devtools.build.lib.skyframe.serialization.DeserializationContext;
+import com.google.devtools.build.lib.skyframe.serialization.AsyncDeserializationContext;
+import com.google.devtools.build.lib.skyframe.serialization.DeferredObjectCodec;
 import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
 import com.google.devtools.build.lib.skyframe.serialization.SerializationContext;
 import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
 import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Root;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import java.io.IOException;
+import java.util.function.Supplier;
 
 /** Codec implementations for {@link Artifact} subclasses. */
 final class ArtifactCodecs {
 
   @SuppressWarnings("unused") // Codec used by reflection.
-  private static final class DerivedArtifactCodec implements ObjectCodec<DerivedArtifact> {
+  private static final class DerivedArtifactCodec extends DeferredObjectCodec<DerivedArtifact> {
 
     @Override
     public Class<DerivedArtifact> getEncodedClass() {
@@ -53,17 +56,52 @@ public void serialize(
     }
 
     @Override
-    public DerivedArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
+    public Supplier<DerivedArtifact> deserializeDeferred(
+        AsyncDeserializationContext context, CodedInputStream codedIn)
         throws SerializationException, IOException {
-      ArtifactRoot root = context.deserialize(codedIn);
-      PathFragment rootRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey = context.deserialize(codedIn);
-      DerivedArtifact artifact =
+      DeserializedDerivedArtifactBuilder builder =
+          new DeserializedDerivedArtifactBuilder(
+              context.getDependency(ArtifactSerializationContext.class));
+      context.deserializeFully(codedIn, builder, DeserializedDerivedArtifactBuilder::setRoot);
+      context.deserializeFully(
+          codedIn, builder, DeserializedDerivedArtifactBuilder::setRootRelativePath);
+      context.deserializeFully(
+          codedIn, builder, DeserializedDerivedArtifactBuilder::setGeneratingActionKey);
+      return builder;
+    }
+  }
+
+  private static class DeserializedDerivedArtifactBuilder implements Supplier<DerivedArtifact> {
+    private final ArtifactSerializationContext context;
+    private ArtifactRoot root;
+    private PathFragment rootRelativePath;
+    private Object generatingActionKey;
+
+    private DeserializedDerivedArtifactBuilder(ArtifactSerializationContext context) {
+      this.context = context;
+    }
+
+    @Override
+    public DerivedArtifact get() {
+      return context.intern(
           new DerivedArtifact(
               root,
               getExecPathForDeserialization(root, rootRelativePath, generatingActionKey),
-              generatingActionKey);
-      return context.getDependency(ArtifactSerializationContext.class).intern(artifact);
+              generatingActionKey));
+    }
+
+    private static void setRoot(DeserializedDerivedArtifactBuilder builder, Object value) {
+      builder.root = (ArtifactRoot) value;
+    }
+
+    private static void setRootRelativePath(
+        DeserializedDerivedArtifactBuilder builder, Object value) {
+      builder.rootRelativePath = (PathFragment) value;
+    }
+
+    private static void setGeneratingActionKey(
+        DeserializedDerivedArtifactBuilder builder, Object value) {
+      builder.generatingActionKey = value;
     }
   }
 
@@ -95,7 +133,7 @@ private static PathFragment getExecPathForDeserialization(
 
   /** {@link ObjectCodec} for {@link SourceArtifact} */
   @SuppressWarnings("unused") // Used by reflection.
-  private static final class SourceArtifactCodec implements ObjectCodec<SourceArtifact> {
+  private static final class SourceArtifactCodec extends DeferredObjectCodec<SourceArtifact> {
 
     @Override
     public Class<SourceArtifact> getEncodedClass() {
@@ -107,25 +145,55 @@ public void serialize(
         SerializationContext context, SourceArtifact obj, CodedOutputStream codedOut)
         throws SerializationException, IOException {
       context.serialize(obj.getExecPath(), codedOut);
-      context.serialize(obj.getRoot(), codedOut);
+      context.serialize(obj.getRoot().getRoot(), codedOut);
       context.serialize(obj.getArtifactOwner(), codedOut);
     }
 
     @Override
-    public SourceArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
+    public Supplier<SourceArtifact> deserializeDeferred(
+        AsyncDeserializationContext context, CodedInputStream codedIn)
         throws SerializationException, IOException {
-      PathFragment execPath = context.deserialize(codedIn);
-      ArtifactRoot artifactRoot = context.deserialize(codedIn);
-      ArtifactOwner owner = context.deserialize(codedIn);
-      return context
-          .getDependency(ArtifactSerializationContext.class)
-          .getSourceArtifact(execPath, artifactRoot.getRoot(), owner);
+      DeserializedSourceArtifactBuilder builder =
+          new DeserializedSourceArtifactBuilder(
+              context.getDependency(ArtifactSerializationContext.class));
+      context.deserializeFully(codedIn, builder, DeserializedSourceArtifactBuilder::setExecPath);
+      context.deserializeFully(codedIn, builder, DeserializedSourceArtifactBuilder::setRoot);
+      context.deserializeFully(codedIn, builder, DeserializedSourceArtifactBuilder::setOwner);
+      return builder;
+    }
+  }
+
+  private static class DeserializedSourceArtifactBuilder implements Supplier<SourceArtifact> {
+    private final ArtifactSerializationContext context;
+    private PathFragment execPath;
+    private Root root;
+    private ArtifactOwner owner;
+
+    private DeserializedSourceArtifactBuilder(ArtifactSerializationContext context) {
+      this.context = context;
+    }
+
+    @Override
+    public SourceArtifact get() {
+      return context.getSourceArtifact(execPath, root, owner);
+    }
+
+    private static void setExecPath(DeserializedSourceArtifactBuilder builder, Object value) {
+      builder.execPath = (PathFragment) value;
+    }
+
+    private static void setRoot(DeserializedSourceArtifactBuilder builder, Object value) {
+      builder.root = (Root) value;
+    }
+
+    private static void setOwner(DeserializedSourceArtifactBuilder builder, Object value) {
+      builder.owner = (ArtifactOwner) value;
     }
   }
 
   // Keep in sync with DerivedArtifactCodec.
   @SuppressWarnings("unused") // Used by reflection.
-  private static final class SpecialArtifactCodec implements ObjectCodec<SpecialArtifact> {
+  private static final class SpecialArtifactCodec extends DeferredObjectCodec<SpecialArtifact> {
 
     @Override
     public Class<SpecialArtifact> getEncodedClass() {
@@ -143,26 +211,66 @@ public void serialize(
     }
 
     @Override
-    public SpecialArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
+    public Supplier<SpecialArtifact> deserializeDeferred(
+        AsyncDeserializationContext context, CodedInputStream codedIn)
         throws SerializationException, IOException {
-      ArtifactRoot root = context.deserialize(codedIn);
-      PathFragment rootRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey = context.deserialize(codedIn);
-      SpecialArtifactType type = context.deserialize(codedIn);
-      SpecialArtifact artifact =
-          new SpecialArtifact(
-              root,
-              getExecPathForDeserialization(root, rootRelativePath, generatingActionKey),
-              generatingActionKey,
-              type);
+      DeserializedSpecialArtifactBuilder builder =
+          new DeserializedSpecialArtifactBuilder(
+              context.getDependency(ArtifactSerializationContext.class));
+      context.deserializeFully(codedIn, builder, DeserializedSpecialArtifactBuilder::setRoot);
+      context.deserializeFully(
+          codedIn, builder, DeserializedSpecialArtifactBuilder::setRootRelativePath);
+      context.deserializeFully(
+          codedIn, builder, DeserializedSpecialArtifactBuilder::setGeneratingActionKey);
+      context.deserializeFully(codedIn, builder, DeserializedSpecialArtifactBuilder::setType);
+      return builder;
+    }
+  }
+
+  private static class DeserializedSpecialArtifactBuilder implements Supplier<SpecialArtifact> {
+    private final ArtifactSerializationContext context;
+    private ArtifactRoot root;
+    private PathFragment rootRelativePath;
+    private Object generatingActionKey;
+    private SpecialArtifactType type;
+
+    private DeserializedSpecialArtifactBuilder(ArtifactSerializationContext context) {
+      this.context = context;
+    }
+
+    @Override
+    public SpecialArtifact get() {
       return (SpecialArtifact)
-          context.getDependency(ArtifactSerializationContext.class).intern(artifact);
+          context.intern(
+              new SpecialArtifact(
+                  root,
+                  getExecPathForDeserialization(root, rootRelativePath, generatingActionKey),
+                  generatingActionKey,
+                  type));
+    }
+
+    private static void setRoot(DeserializedSpecialArtifactBuilder builder, Object value) {
+      builder.root = (ArtifactRoot) value;
+    }
+
+    private static void setRootRelativePath(
+        DeserializedSpecialArtifactBuilder builder, Object value) {
+      builder.rootRelativePath = (PathFragment) value;
+    }
+
+    private static void setGeneratingActionKey(
+        DeserializedSpecialArtifactBuilder builder, Object value) {
+      builder.generatingActionKey = value;
+    }
+
+    private static void setType(DeserializedSpecialArtifactBuilder builder, Object value) {
+      builder.type = (SpecialArtifactType) value;
     }
   }
 
   @SuppressWarnings("unused") // Codec used by reflection.
   private static final class ArchivedTreeArtifactCodec
-      implements ObjectCodec<ArchivedTreeArtifact> {
+      extends DeferredObjectCodec<ArchivedTreeArtifact> {
 
     @Override
     public Class<ArchivedTreeArtifact> getEncodedClass() {
@@ -181,24 +289,55 @@ public void serialize(
     }
 
     @Override
-    public ArchivedTreeArtifact deserialize(
-        DeserializationContext context, CodedInputStream codedIn)
+    public Supplier<ArchivedTreeArtifact> deserializeDeferred(
+        AsyncDeserializationContext context, CodedInputStream codedIn)
         throws SerializationException, IOException {
-      SpecialArtifact treeArtifact = context.deserialize(codedIn);
-      PathFragment derivedTreeRoot = context.deserialize(codedIn);
-      PathFragment rootRelativePath = context.deserialize(codedIn);
+      DeserializedArchivedTreeArtifactBuilder builder =
+          new DeserializedArchivedTreeArtifactBuilder();
+      context.deserializeFully(
+          codedIn, builder, DeserializedArchivedTreeArtifactBuilder::setTreeArtifact);
+      context.deserializeFully(
+          codedIn, builder, DeserializedArchivedTreeArtifactBuilder::setDerivedTreeRoot);
+      context.deserializeFully(
+          codedIn, builder, DeserializedArchivedTreeArtifactBuilder::setRootRelativePath);
+      return builder;
+    }
+  }
+
+  private static class DeserializedArchivedTreeArtifactBuilder
+      implements Supplier<ArchivedTreeArtifact> {
+    private SpecialArtifact treeArtifact;
+    private PathFragment derivedTreeRoot;
+    private PathFragment rootRelativePath;
+
+    @Override
+    public ArchivedTreeArtifact get() {
       Object generatingActionKey =
           treeArtifact.hasGeneratingActionKey()
               ? treeArtifact.getGeneratingActionKey()
               : OMITTED_FOR_SERIALIZATION;
-
       return ArchivedTreeArtifact.createInternal(
           treeArtifact, derivedTreeRoot, rootRelativePath, generatingActionKey);
     }
+
+    private static void setTreeArtifact(
+        DeserializedArchivedTreeArtifactBuilder builder, Object value) {
+      builder.treeArtifact = (SpecialArtifact) value;
+    }
+
+    private static void setDerivedTreeRoot(
+        DeserializedArchivedTreeArtifactBuilder builder, Object value) {
+      builder.derivedTreeRoot = (PathFragment) value;
+    }
+
+    private static void setRootRelativePath(
+        DeserializedArchivedTreeArtifactBuilder builder, Object value) {
+      builder.rootRelativePath = (PathFragment) value;
+    }
   }
 
   @SuppressWarnings("unused") // Used by reflection.
-  private static final class TreeFileArtifactCodec implements ObjectCodec<TreeFileArtifact> {
+  private static final class TreeFileArtifactCodec extends DeferredObjectCodec<TreeFileArtifact> {
 
     @Override
     public Class<TreeFileArtifact> getEncodedClass() {
@@ -215,13 +354,42 @@ public void serialize(
     }
 
     @Override
-    public TreeFileArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
+    public Supplier<TreeFileArtifact> deserializeDeferred(
+        AsyncDeserializationContext context, CodedInputStream codedIn)
         throws SerializationException, IOException {
-      SpecialArtifact parent = context.deserialize(codedIn);
-      PathFragment parentRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey = context.deserialize(codedIn);
+      DeserializedTreeFileArtifactBuilder builder = new DeserializedTreeFileArtifactBuilder();
+      context.deserializeFully(codedIn, builder, DeserializedTreeFileArtifactBuilder::setParent);
+      context.deserializeFully(
+          codedIn, builder, DeserializedTreeFileArtifactBuilder::setParentRelativePath);
+      context.deserializeFully(
+          codedIn, builder, DeserializedTreeFileArtifactBuilder::setGeneratingActionKey);
+      return builder;
+    }
+  }
+
+  private static class DeserializedTreeFileArtifactBuilder implements Supplier<TreeFileArtifact> {
+    private SpecialArtifact parent;
+    private PathFragment parentRelativePath;
+    private Object generatingActionKey;
+
+    @Override
+    public TreeFileArtifact get() {
       return new TreeFileArtifact(parent, parentRelativePath, generatingActionKey);
     }
+
+    private static void setParent(DeserializedTreeFileArtifactBuilder builder, Object value) {
+      builder.parent = (SpecialArtifact) value;
+    }
+
+    private static void setParentRelativePath(
+        DeserializedTreeFileArtifactBuilder builder, Object value) {
+      builder.parentRelativePath = (PathFragment) value;
+    }
+
+    private static void setGeneratingActionKey(
+        DeserializedTreeFileArtifactBuilder builder, Object value) {
+      builder.generatingActionKey = value;
+    }
   }
 
   private ArtifactCodecs() {}