Moves Artifact codec implementations out from Artifact class.

This pure refactor helps to encapsulate upcoming codec changes.

PiperOrigin-RevId: 597584825
Change-Id: Iab66a47a9979b30a64810e2e5f6f3084f32ef273

Author: aoeui

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

@@ -35,10 +35,6 @@
 import com.google.devtools.build.lib.collect.nestedset.NestedSet;
 import com.google.devtools.build.lib.concurrent.ThreadSafety;
 import com.google.devtools.build.lib.skyframe.SkyFunctions;
-import com.google.devtools.build.lib.skyframe.serialization.DeserializationContext;
-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.skyframe.serialization.VisibleForSerialization;
 import com.google.devtools.build.lib.skyframe.serialization.autocodec.SerializationConstant;
 import com.google.devtools.build.lib.starlarkbuildapi.FileApi;
@@ -51,9 +47,6 @@
 import com.google.devtools.build.skyframe.ExecutionPhaseSkyKey;
 import com.google.devtools.build.skyframe.SkyFunctionName;
 import com.google.devtools.build.skyframe.SkyKey;
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
@@ -363,7 +356,8 @@ public static DerivedArtifact create(
       return new DerivedArtifact(root, execPath, owner, contentBasedPath);
     }
 
-    private DerivedArtifact(ArtifactRoot root, PathFragment execPath, Object owner) {
+    @VisibleForSerialization
+    DerivedArtifact(ArtifactRoot root, PathFragment execPath, Object owner) {
       this(root, execPath, owner, /*contentBasedPath=*/ false);
     }
 
@@ -504,64 +498,6 @@ public String toString() {
         }
       };
 
-  @SuppressWarnings("unused") // Codec used by reflection.
-  private static final class DerivedArtifactCodec implements ObjectCodec<DerivedArtifact> {
-
-    @Override
-    public Class<DerivedArtifact> getEncodedClass() {
-      return DerivedArtifact.class;
-    }
-
-    @Override
-    public void serialize(
-        SerializationContext context, DerivedArtifact obj, CodedOutputStream codedOut)
-        throws SerializationException, IOException {
-      context.serialize(obj.getRoot(), codedOut);
-      context.serialize(obj.getRootRelativePath(), codedOut);
-      context.serialize(getGeneratingActionKeyForSerialization(obj, context), codedOut);
-    }
-
-    @Override
-    public DerivedArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
-        throws SerializationException, IOException {
-      ArtifactRoot root = context.deserialize(codedIn);
-      PathFragment rootRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey = context.deserialize(codedIn);
-      DerivedArtifact artifact =
-          new DerivedArtifact(
-              root,
-              getExecPathForDeserialization(root, rootRelativePath, generatingActionKey),
-              generatingActionKey);
-      return context.getDependency(ArtifactSerializationContext.class).intern(artifact);
-    }
-  }
-
-  private static Object getGeneratingActionKeyForSerialization(
-      DerivedArtifact artifact, SerializationContext context) {
-    return context
-            .getDependency(ArtifactSerializationContext.class)
-            .includeGeneratingActionKey(artifact)
-        ? artifact.getGeneratingActionKey()
-        : OMITTED_FOR_SERIALIZATION;
-  }
-
-  private static PathFragment getExecPathForDeserialization(
-      ArtifactRoot root, PathFragment rootRelativePath, Object generatingActionKey) {
-    Preconditions.checkArgument(
-        !root.isSourceRoot(),
-        "Root not derived: %s (rootRelativePath=%s, generatingActionKey=%s)",
-        root,
-        rootRelativePath,
-        generatingActionKey);
-    Preconditions.checkArgument(
-        root.getRoot().isAbsolute() == rootRelativePath.isAbsolute(),
-        "Illegal root relative path: %s (root=%s, generatingActionKey=%s)",
-        rootRelativePath,
-        root,
-        generatingActionKey);
-    return root.getExecPath().getRelative(rootRelativePath);
-  }
-
   public final Path getPath() {
     return root.getRoot().getRelative(getRootRelativePath());
   }
@@ -986,36 +922,6 @@ boolean differentOwnerOrRoot(ArtifactOwner owner, ArtifactRoot root) {
     }
   }
 
-  /** {@link ObjectCodec} for {@link SourceArtifact} */
-  @SuppressWarnings("unused") // Used by reflection.
-  private static final class SourceArtifactCodec implements ObjectCodec<SourceArtifact> {
-
-    @Override
-    public Class<SourceArtifact> getEncodedClass() {
-      return SourceArtifact.class;
-    }
-
-    @Override
-    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.getArtifactOwner(), codedOut);
-    }
-
-    @Override
-    public SourceArtifact deserialize(DeserializationContext 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);
-    }
-  }
-
   /**
    * Special artifact types.
    *
@@ -1055,7 +961,8 @@ public static SpecialArtifact create(
       return new SpecialArtifact(root, execPath, owner, type);
     }
 
-    private SpecialArtifact(
+    @VisibleForSerialization
+    SpecialArtifact(
         ArtifactRoot root, PathFragment execPath, Object owner, SpecialArtifactType type) {
       super(root, execPath, owner);
       this.type = type;
@@ -1096,42 +1003,10 @@ public PathFragment getParentRelativePath() {
     public boolean valueIsShareable() {
       return !isConstantMetadata();
     }
-  }
-
-  // Keep in sync with DerivedArtifactCodec.
-  @SuppressWarnings("unused") // Used by reflection.
-  private static final class SpecialArtifactCodec implements ObjectCodec<SpecialArtifact> {
 
-    @Override
-    public Class<SpecialArtifact> getEncodedClass() {
-      return SpecialArtifact.class;
-    }
-
-    @Override
-    public void serialize(
-        SerializationContext context, SpecialArtifact obj, CodedOutputStream codedOut)
-        throws SerializationException, IOException {
-      context.serialize(obj.getRoot(), codedOut);
-      context.serialize(obj.getRootRelativePath(), codedOut);
-      context.serialize(getGeneratingActionKeyForSerialization(obj, context), codedOut);
-      context.serialize(obj.type, codedOut);
-    }
-
-    @Override
-    public SpecialArtifact deserialize(DeserializationContext 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);
-      return (SpecialArtifact)
-          context.getDependency(ArtifactSerializationContext.class).intern(artifact);
+    @VisibleForSerialization
+    SpecialArtifactType getSpecialArtifactType() {
+      return type;
     }
   }
 
@@ -1202,7 +1077,8 @@ public static ArchivedTreeArtifact createWithCustomDerivedTreeRoot(
           treeArtifact, derivedTreeRoot, rootRelativePath, treeArtifact.getGeneratingActionKey());
     }
 
-    private static ArchivedTreeArtifact createInternal(
+    @VisibleForSerialization
+    static ArchivedTreeArtifact createInternal(
         SpecialArtifact treeArtifact,
         PathFragment derivedTreeRoot,
         PathFragment rootRelativePath,
@@ -1253,43 +1129,6 @@ private static Path getExecRoot(ArtifactRoot artifactRoot) {
     }
   }
 
-  @SuppressWarnings("unused") // Codec used by reflection.
-  private static final class ArchivedTreeArtifactCodec
-      implements ObjectCodec<ArchivedTreeArtifact> {
-
-    @Override
-    public Class<ArchivedTreeArtifact> getEncodedClass() {
-      return ArchivedTreeArtifact.class;
-    }
-
-    @Override
-    public void serialize(
-        SerializationContext context, ArchivedTreeArtifact obj, CodedOutputStream codedOut)
-        throws SerializationException, IOException {
-      PathFragment derivedTreeRoot = obj.getRoot().getExecPath().subFragment(1, 2);
-
-      context.serialize(obj.getParent(), codedOut);
-      context.serialize(derivedTreeRoot, codedOut);
-      context.serialize(obj.getRootRelativePath(), codedOut);
-    }
-
-    @Override
-    public ArchivedTreeArtifact deserialize(
-        DeserializationContext context, CodedInputStream codedIn)
-        throws SerializationException, IOException {
-      SpecialArtifact treeArtifact = context.deserialize(codedIn);
-      PathFragment derivedTreeRoot = context.deserialize(codedIn);
-      PathFragment rootRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey =
-          treeArtifact.hasGeneratingActionKey()
-              ? treeArtifact.getGeneratingActionKey()
-              : OMITTED_FOR_SERIALIZATION;
-
-      return ArchivedTreeArtifact.createInternal(
-          treeArtifact, derivedTreeRoot, rootRelativePath, generatingActionKey);
-    }
-  }
-
   /**
    * A special kind of artifact that represents a concrete file created at execution time under its
    * associated parent TreeArtifact.
@@ -1378,8 +1217,8 @@ public static TreeFileArtifact createTemplateExpansionOutput(
       return createTemplateExpansionOutput(parent, PathFragment.create(parentRelativePath), owner);
     }
 
-    private TreeFileArtifact(
-        SpecialArtifact parent, PathFragment parentRelativePath, Object owner) {
+    @VisibleForSerialization
+    TreeFileArtifact(SpecialArtifact parent, PathFragment parentRelativePath, Object owner) {
       super(parent.getRoot(), parent.getExecPath().getRelative(parentRelativePath), owner);
       Preconditions.checkArgument(
           parent.isTreeArtifact(),
@@ -1419,33 +1258,6 @@ private static boolean isActionTemplateExpansionKey(ActionLookupKey key) {
     }
   }
 
-  @SuppressWarnings("unused") // Used by reflection.
-  private static final class TreeFileArtifactCodec implements ObjectCodec<TreeFileArtifact> {
-
-    @Override
-    public Class<TreeFileArtifact> getEncodedClass() {
-      return TreeFileArtifact.class;
-    }
-
-    @Override
-    public void serialize(
-        SerializationContext context, TreeFileArtifact obj, CodedOutputStream codedOut)
-        throws SerializationException, IOException {
-      context.serialize(obj.parent, codedOut);
-      context.serialize(obj.parentRelativePath, codedOut);
-      context.serialize(getGeneratingActionKeyForSerialization(obj, context), codedOut);
-    }
-
-    @Override
-    public TreeFileArtifact deserialize(DeserializationContext context, CodedInputStream codedIn)
-        throws SerializationException, IOException {
-      SpecialArtifact parent = context.deserialize(codedIn);
-      PathFragment parentRelativePath = context.deserialize(codedIn);
-      Object generatingActionKey = context.deserialize(codedIn);
-      return new TreeFileArtifact(parent, parentRelativePath, generatingActionKey);
-    }
-  }
-
   // ---------------------------------------------------------------------------
   // Static methods to assist in working with Artifacts