* build.lib.packages API: for example, low-level intermediaries internal to a given rule,
* such as a Java class files or C++ object files. However all FileTargets have a corresponding
* Artifact.
*
* In any given call to SkyframeExecutor#buildArtifacts(), no two Artifacts in the action graph * may refer to the same path. * *
Artifacts generally fall into two classifications, source and derived, but there exist a few * other cases that are fuzzy and difficult to classify. The following cases exist: * *
See {@link ArtifactRoot} for a detailed example on root, execRoot, and related paths. * *
In the usual case, an Artifact represents a single file. However, an Artifact may also * represent the following: * *
While Artifact implements {@link SkyKey} for memory-saving purposes, Skyframe requests
* involving artifacts should always go through {@link Artifact#key} since ordinary derived
* artifacts should not be requested directly from Skyframe.
*/
public abstract class Artifact
implements FileType.HasFileType,
ActionInput,
FileApi,
Comparable TODO(janakr): Avoid this issue entirely by giving {@link SourceArtifact} its own {@code
* SkyFunction}. Then we can just declare that function to be non-hermetic. That will also save
* memory since we can make mandatory source artifacts their own SkyKeys!
*/
public static final SkyFunctionName ARTIFACT = SkyFunctionName.createHermetic("ARTIFACT");
/**
* Returns a {@link SkyKey} that, when built, will produce this artifact. For source artifacts and
* generated artifacts that may aggregate other artifacts, returns the artifact itself. For normal
* generated artifacts, returns the key of the generating action.
*
* Callers should use this method (or the related ones below) in preference to directly
* requesting an {@link Artifact} to be built by Skyframe, since ordinary derived artifacts should
* never be directly built by Skyframe.
*/
@ThreadSafety.ThreadSafe
public static SkyKey key(Artifact artifact) {
if (artifact.isTreeArtifact()
|| artifact.isMiddlemanArtifact()
|| !artifact.hasKnownGeneratingAction()) {
return artifact;
}
return ((DerivedArtifact) artifact).getGeneratingActionKey();
}
public static Collection {@code artifact.isMiddlemanArtifact() || artifact.isTreeArtifact()} must be true. Only
* middlemen and tree artifacts are expanded.
*/
void expand(Artifact artifact, Collection output);
/**
* Returns the expansion of Fileset for the given artifact.
*
* @param artifact {@code artifact.isFileset()} must be true.
* @throws MissingExpansionException if the expander is missing data needed to expand provided
* fileset.
*/
default ImmutableList The {@linkplain ArchivedTreeArtifact archived tree artifact} can be used instead of the
* tree artifact expansion.
*/
@Nullable
default ArchivedTreeArtifact getArchivedTreeArtifact(SpecialArtifact treeArtifact) {
return null;
}
}
/**
* Exception thrown when attempting to {@linkplain ArtifactExpander expand} an artifact for which
* we do not have the necessary data.
*/
public static final class MissingExpansionException extends Exception {
public MissingExpansionException(String message) {
super(message);
}
}
/** Implementation of {@link ArtifactExpander} */
public static class ArtifactExpanderImpl implements ArtifactExpander {
private final Map We overload this field in order to save memory.
*/
private Object owner;
/**
* Content-based output paths are experimental. Only derived artifacts that are explicitly opted
* in by their creating rules should use them and only when {@link
* com.google.devtools.build.lib.analysis.config.BuildConfigurationValue#useContentBasedOutputPaths}
* is on.
*/
private final boolean contentBasedPath;
/** Standard factory method for derived artifacts. */
public static DerivedArtifact create(
ArtifactRoot root, PathFragment execPath, ActionLookupKey owner) {
return create(root, execPath, owner, /*contentBasedPath=*/ false);
}
/**
* Same as {@link #create(ArtifactRoot, PathFragment, ActionLookupKeyOrOwner)} but includes the
* option to use a content-based path for this artifact (see {@link
* com.google.devtools.build.lib.analysis.config.BuildConfigurationValue#useContentBasedOutputPaths}).
*/
public static DerivedArtifact create(
ArtifactRoot root, PathFragment execPath, ActionLookupKey owner, boolean contentBasedPath) {
return new DerivedArtifact(root, execPath, owner, contentBasedPath);
}
private DerivedArtifact(ArtifactRoot root, PathFragment execPath, Object owner) {
this(root, execPath, owner, /*contentBasedPath=*/ false);
}
private DerivedArtifact(
ArtifactRoot root, PathFragment execPath, Object owner, boolean contentBasedPath) {
super(root, execPath, HashCodes.hashObjects(execPath, getOwnerToUseForHashCode(owner)));
Preconditions.checkState(
!root.getExecPath().isEmpty(), "Derived root has no exec path: %s, %s", root, execPath);
this.owner = Preconditions.checkNotNull(owner);
this.contentBasedPath = contentBasedPath;
}
/**
* Called when a configured target's actions are being collected. {@code generatingActionKey}
* must have the same owner as this artifact's current {@link #getArtifactOwner}.
*/
@VisibleForTesting
public final void setGeneratingActionKey(ActionLookupData generatingActionKey) {
Preconditions.checkState(
this.owner != OMITTED_FOR_SERIALIZATION, "Owner was omitted for serialization: %s", this);
Preconditions.checkState(
this.owner instanceof ActionLookupKey,
"Already set generating action key: %s (%s %s)",
this,
this.owner,
generatingActionKey);
Preconditions.checkState(
Preconditions.checkNotNull(generatingActionKey, this).getActionLookupKey().equals(owner),
"Owner of generating action key not same as artifact's owner: %s (%s %s)",
this,
this.owner,
generatingActionKey);
this.owner = generatingActionKey;
}
@VisibleForTesting
public final boolean hasGeneratingActionKey() {
return this.owner instanceof ActionLookupData;
}
/** Can only be called once {@link #setGeneratingActionKey} is called. */
public final ActionLookupData getGeneratingActionKey() {
Preconditions.checkState(owner instanceof ActionLookupData, "Bad owner: %s %s", this, owner);
return (ActionLookupData) owner;
}
@Override
public final ActionLookupKey getArtifactOwner() {
Preconditions.checkState(
this.owner != OMITTED_FOR_SERIALIZATION, "Owner was omitted for serialization: %s", this);
return owner instanceof ActionLookupData
? getGeneratingActionKey().getActionLookupKey()
: (ActionLookupKey) owner;
}
/**
* Returns the object to use for the hash code for this artifact's owner, with the goal of being
* consistent across calls to {@link #setGeneratingActionKey} and also serialization.
*/
private static Object getOwnerToUseForHashCode(Object owner) {
return owner instanceof ActionLookupData
? ((ActionLookupData) owner).getActionLookupKey()
: owner;
}
@Override
public final Label getOwnerLabel() {
return getArtifactOwner().getLabel();
}
@Override
public final String toDebugString() {
if (hasGeneratingActionKey() || owner == OMITTED_FOR_SERIALIZATION) {
return super.toDetailString() + " (" + owner + ")";
}
return super.toDebugString();
}
@Override
public final PathFragment getRootRelativePath() {
return getExecPath().relativeTo(getRoot().getExecPath());
}
@Override
final boolean ownersEqual(Artifact other) {
DerivedArtifact that = (DerivedArtifact) other;
if (!(this.owner instanceof ActionLookupData) || !(that.owner instanceof ActionLookupData)) {
// Happens when at least one of these artifacts hasn't had its generating action key set
// yet, so its configured target is still being analyzed. Tolerate.
return this.getArtifactOwner().equals(that.getArtifactOwner());
}
return this.owner.equals(that.owner);
}
@Override
public boolean contentBasedPath() {
return contentBasedPath;
}
@Override
public String expand(UnaryOperator If {@code false} is returned, upon deserialization the generating action key is replaced
* with the marker {@link #OMITTED_FOR_SERIALIZATION}. The artifact is then only intended for
* use with {@link #equalsWithoutOwner} or {@link OwnerlessArtifactWrapper} - any operation
* accessing the generating action key will fail.
*/
default boolean includeGeneratingActionKey(DerivedArtifact artifact) {
return true;
}
default DerivedArtifact intern(DerivedArtifact original) {
return original;
}
}
/**
* Marker stored in place of the generating action key for deserialized artifacts when {@link
* ArtifactSerializationContext#includeGeneratingActionKey} is {@code false}.
*/
@SerializationConstant @VisibleForSerialization
static final Object OMITTED_FOR_SERIALIZATION =
new Object() {
@Override
public String toString() {
return "OMITTED_FOR_SERIALIZATION";
}
};
@SuppressWarnings("unused") // Codec used by reflection.
private static final class DerivedArtifactCodec implements ObjectCodec The directory name is always a relative path to the execution directory.
*/
@Override
public final String getDirname() {
PathFragment parent = execPath.getParentDirectory();
return (parent == null) ? "/" : parent.getSafePathString();
}
/**
* Returns the base file name of this artifact, similar to basename(1).
*/
@Override
public final String getFilename() {
return execPath.getBaseName();
}
@Override
public final String getExtension() {
return execPath.getFileExtension();
}
/**
* Checks whether this artifact is of the supplied file type.
*
* Prefer this method to pulling out strings from the Artifact and passing to {@link
* FileType#apply(String)} manually. This method has been optimized to generate a minimum of
* garbage.
*/
public boolean isFileType(FileType fileType) {
return fileType.matches(this);
}
/** Checks whether this artifact is of one of the types in the supplied set. */
public boolean isFileType(FileTypeSet fileTypeSet) {
return fileTypeSet.matches(filePathForFileTypeMatcher());
}
@Override
public final String filePathForFileTypeMatcher() {
return execPath.filePathForFileTypeMatcher();
}
@Override
public final String expandToCommandLine() {
return getExecPathString();
}
/** Returns the artifact's owning label. May be null. */
@Nullable
public final Label getOwner() {
return getOwnerLabel();
}
/**
* Gets the {@code ActionLookupKey} of the {@code ConfiguredTarget} that owns this artifact, if it
* was set. Otherwise, this should be a dummy value -- either {@link ArtifactOwner#NULL_OWNER} or
* a dummy owner set in tests. Such a dummy value should only occur for source artifacts if
* created without specifying the owner, or for special derived artifacts, such as target
* completion middleman artifacts, build info artifacts, and the like.
*/
public abstract ArtifactOwner getArtifactOwner();
/**
* Returns the root beneath which this Artifact resides, if any. This may be one of the
* package-path entries (for source Artifacts), or one of the bin, genfiles or includes dirs (for
* derived Artifacts). It will always be an ancestor of getPath().
*/
@Override
public final ArtifactRoot getRoot() {
return root;
}
@Override
public final PathFragment getExecPath() {
return execPath;
}
/**
* Returns the relative path to this artifact relative to its root. It makes no guarantees as to
* the semantic meaning or the completeness of the returned path value. In other words, no
* assumptions should be made in terms of where the root portion of the path ends, and the
* returned value almost always needs to be used in conjunction with its root.
*
* {#link Artifact#getOutputDirRelativePath()} is more versatile for general use cases.
*/
public abstract PathFragment getRootRelativePath();
/**
* Returns the fully-qualified package path to this artifact. By "fully-qualified", it means the
* returned path is prefixed with "external/ Do not call this method just because you need a path prefixed with the "external/ An {@link Artifact} is a {@link SourceArtifact} iff this returns true, and a {@link
* DerivedArtifact} otherwise.
*/
@Override
public final boolean isSourceArtifact() {
return root.isSourceRoot();
}
/**
* Returns true iff this artifact has a generating action, and that generating action is known.
*/
public boolean hasKnownGeneratingAction() {
return !isSourceArtifact();
}
/**
* Returns true iff this is a middleman Artifact as determined by its root.
*
* If true, this artifact is necessarily a {@link DerivedArtifact}.
*/
public final boolean isMiddlemanArtifact() {
return root.isMiddlemanRoot();
}
/**
* Returns true iff this is a TreeArtifact representing a directory tree containing Artifacts.
*
* if true, this artifact is necessarily a {@link SpecialArtifact} with type {@link
* SpecialArtifactType#TREE}.
*/
public boolean isTreeArtifact() {
return false;
}
/**
* Returns {@code true} if this is a {@link TreeFileArtifact} that was created by an action which
* declared an output directory, as opposed to an action that was generated by an action template
* expansion.
*
* Such artifacts should always be stored within a {@link
* com.google.devtools.build.lib.skyframe.TreeArtifactValue} representing the declared directory
* and all children, not individually like other derived artifacts.
*/
public boolean isChildOfDeclaredDirectory() {
return false;
}
/**
* Returns whether the artifact represents a Fileset.
*
* if true, this artifact is necessarily a {@link SpecialArtifact} with type {@link
* SpecialArtifactType#FILESET}.
*/
public boolean isFileset() {
return false;
}
/** The disjunction of {@link #isTreeArtifact} and {@link #isFileset}. */
@Override
public boolean isDirectory() {
return isTreeArtifact() || isFileset();
}
/**
* Returns true iff metadata cache must return constant metadata for the given artifact.
*
* If true, this artifact is necessarily a {@link SpecialArtifact} with type {@link
* SpecialArtifactType#CONSTANT_METADATA}.
*/
public boolean isConstantMetadata() {
return false;
}
/**
* For targets in external repositories, this returns the path the artifact live at in the
* runfiles tree. For local targets, it returns the rootRelativePath.
*/
public final PathFragment getRunfilesPath() {
PathFragment relativePath = getRootRelativePath();
// Runfile paths for external artifacts should be prefixed with "../ Source artifacts have the property that unlike for output artifacts, direct file system
* access for their contents should be safe, even in a distributed context.
*
* TODO(shahan): move {@link Artifact#getPath} to this subclass.
*/
public static final class SourceArtifact extends Artifact {
private final ArtifactOwner owner;
@VisibleForTesting
public SourceArtifact(ArtifactRoot root, PathFragment execPath, ArtifactOwner owner) {
super(root, execPath, execPath.hashCode());
this.owner = owner;
}
/**
* Source artifacts do not consider their owners in equality checks, since their owners are
* purely cosmetic.
*/
@Override
boolean ownersEqual(Artifact other) {
return true;
}
@Override
public PathFragment getRootRelativePath() {
return getRoot().isExternal() ? getExecPath().subFragment(2) : getExecPath();
}
@Override
public PathFragment getPathForLocationExpansion() {
return getExecPath();
}
@Override
public PathFragment getOutputDirRelativePath(boolean siblingRepositoryLayout) {
return siblingRepositoryLayout ? getRepositoryRelativePath() : getExecPath();
}
@Override
public PathFragment getRepositoryRelativePath() {
return getRootRelativePath();
}
@Override
public ArtifactOwner getArtifactOwner() {
return owner;
}
@Override
public Label getOwnerLabel() {
return owner.getLabel();
}
boolean differentOwnerOrRoot(ArtifactOwner owner, ArtifactRoot root) {
return !this.owner.equals(owner) || !this.getRoot().equals(root);
}
}
/** {@link ObjectCodec} for {@link SourceArtifact} */
@SuppressWarnings("unused") // Used by reflection.
private static final class SourceArtifactCodec implements ObjectCodec We subclass {@link DerivedArtifact} instead of storing the special attributes inside in
* order to save memory. The proportion of artifacts that are special is very small, and by not
* having to keep around the attribute for the rest we save some memory.
*/
public static final class SpecialArtifact extends DerivedArtifact {
private final SpecialArtifactType type;
@VisibleForTesting
public static SpecialArtifact create(
ArtifactRoot root, PathFragment execPath, ActionLookupKey owner, SpecialArtifactType type) {
return new SpecialArtifact(root, execPath, owner, type);
}
private SpecialArtifact(
ArtifactRoot root, PathFragment execPath, Object owner, SpecialArtifactType type) {
super(root, execPath, owner);
this.type = type;
}
@Override
public boolean isFileset() {
return type == SpecialArtifactType.FILESET;
}
@Override
public boolean isConstantMetadata() {
return type == SpecialArtifactType.CONSTANT_METADATA;
}
@Override
public boolean isTreeArtifact() {
return type == SpecialArtifactType.TREE;
}
@Override
public boolean isSymlink() {
return type == SpecialArtifactType.UNRESOLVED_SYMLINK;
}
@Override
public boolean hasParent() {
return false;
}
@Override
@Nullable
public PathFragment getParentRelativePath() {
return null;
}
@Override
public boolean valueIsShareable() {
return !isConstantMetadata();
}
}
// Keep in sync with DerivedArtifactCodec.
@SuppressWarnings("unused") // Used by reflection.
private static final class SpecialArtifactCodec implements ObjectCodec The archive is equivalent to the entire tree artifact -- it contains all of the {@linkplain
* TreeFileArtifact children} (and nothing else) of the tree artifact with their filesystem
* structure, relative to the {@linkplain SpecialArtifact#getExecPath() tree artifact directory}.
*/
public static final class ArchivedTreeArtifact extends DerivedArtifact {
private static final PathFragment DEFAULT_DERIVED_TREE_ROOT =
PathFragment.create(":archived_tree_artifacts");
private final SpecialArtifact treeArtifact;
private ArchivedTreeArtifact(
SpecialArtifact treeArtifact,
ArtifactRoot root,
PathFragment execPath,
Object generatingActionKey) {
super(root, execPath, generatingActionKey);
Preconditions.checkArgument(
treeArtifact.isTreeArtifact(), "Not a tree artifact: %s", treeArtifact);
this.treeArtifact = treeArtifact;
}
@Override
public SpecialArtifact getParent() {
return treeArtifact;
}
/**
* Creates an {@link ArchivedTreeArtifact} for a given tree artifact at the path inferred from
* the provided tree.
*
* Returned artifact is stored in a permanent location, therefore can be shared across
* actions and builds.
*
* Example: for a tree artifact of {@code bazel-out/k8-fastbuild/bin/directory} returns an
* {@linkplain ArchivedTreeArtifact artifact} of: {@code
* bazel-out/:archived_tree_artifacts/k8-fastbuild/bin/directory.zip}.
*/
public static ArchivedTreeArtifact createForTree(SpecialArtifact treeArtifact) {
return createInternal(
treeArtifact,
DEFAULT_DERIVED_TREE_ROOT,
treeArtifact.getRootRelativePath().replaceName(treeArtifact.getFilename() + ".zip"),
treeArtifact.getGeneratingActionKey());
}
/**
* Creates an {@link ArchivedTreeArtifact} for a given tree artifact within provided derived
* tree directory.
*
* Example: for a tree artifact with root of {@code bazel-out/k8-fastbuild/bin} returns an
* {@linkplain ArchivedTreeArtifact artifact} of: {@code
* bazel-out/{derivedTreeRoot}/k8-fastbuild/bin/{rootRelativePath}} with root of: {@code
* bazel-out/{derivedTreeRoot}/k8-fastbuild/bin}.
*
* Such artifacts should only be used as outputs of intermediate spawns. Action execution
* results must come from {@link #createForTree}.
*/
public static ArchivedTreeArtifact createWithCustomDerivedTreeRoot(
SpecialArtifact treeArtifact, PathFragment derivedTreeRoot, PathFragment rootRelativePath) {
return createInternal(
treeArtifact, derivedTreeRoot, rootRelativePath, treeArtifact.getGeneratingActionKey());
}
private static ArchivedTreeArtifact createInternal(
SpecialArtifact treeArtifact,
PathFragment derivedTreeRoot,
PathFragment rootRelativePath,
Object generatingActionKey) {
ArtifactRoot treeRoot = treeArtifact.getRoot();
PathFragment archiveRoot = embedDerivedTreeRoot(treeRoot.getExecPath(), derivedTreeRoot);
return new ArchivedTreeArtifact(
treeArtifact,
ArtifactRoot.asDerivedRoot(getExecRoot(treeRoot), RootType.Output, archiveRoot),
archiveRoot.getRelative(rootRelativePath),
generatingActionKey);
}
/**
* Returns an exec path within the archived artifacts directory tree corresponding to the
* provided one.
*
* Example: {@code bazel-out/k8-fastbuild/bin ->
* bazel-out/{customDerivedTreeRoot}/k8-fastbuild/bin}.
*/
public static PathFragment getExecPathWithinArchivedArtifactsTree(PathFragment execPath) {
return embedDerivedTreeRoot(execPath, DEFAULT_DERIVED_TREE_ROOT);
}
/**
* Translates provided output {@code execPath} to one under provided derived tree root.
*
* Example: {@code bazel-out/k8-fastbuild/bin ->
* bazel-out/{derivedTreeRoot}/k8-fastbuild/bin}.
*/
private static PathFragment embedDerivedTreeRoot(
PathFragment execPath, PathFragment derivedTreeRoot) {
return execPath
.subFragment(0, 1)
.getRelative(derivedTreeRoot)
.getRelative(execPath.subFragment(1));
}
private static Path getExecRoot(ArtifactRoot artifactRoot) {
// /output_base/execroot/bazel-out/k8-fastbuild/bin
Path rootPath = artifactRoot.getRoot().asPath();
PathFragment rootPathFragment = rootPath.asFragment();
// /output_base/execroot
PathFragment execRootPath =
rootPathFragment.subFragment(
0, rootPathFragment.segmentCount() - artifactRoot.getExecPath().segmentCount());
return rootPath.getFileSystem().getPath(execRootPath);
}
}
@SuppressWarnings("unused") // Codec used by reflection.
private static final class ArchivedTreeArtifactCodec
implements ObjectCodec TreeFileArtifacts should be only created during execution time inside some special actions
* to support action inputs and outputs that are unpredictable at analysis time. TreeFileArtifacts
* should not be created directly by any rules at analysis time.
*
* There are two types of TreeFileArtifacts:
*
* The child should already have been created by the parent's generating action. For this
* reason, {@link DerivedArtifact#hasGeneratingActionKey} on the parent must be {@code true}
* when this is called. The child is set with the same generating action.
*/
public static TreeFileArtifact createTreeOutput(
SpecialArtifact parent, PathFragment parentRelativePath) {
Preconditions.checkArgument(
parent.hasGeneratingActionKey(),
"%s has no generating action key (parent owner: %s, parent relative path: %s)",
parent,
parent.getArtifactOwner(),
parentRelativePath);
ActionLookupData generatingActionKey = parent.getGeneratingActionKey();
Preconditions.checkArgument(
!isActionTemplateExpansionKey(generatingActionKey.getActionLookupKey()),
"%s owned by action template expansion %s (parent relative path: %s)",
parent,
generatingActionKey.getActionLookupKey(),
parentRelativePath);
return new TreeFileArtifact(parent, parentRelativePath, generatingActionKey);
}
/**
* Convenience method for {@link #createTreeOutput(SpecialArtifact, PathFragment)} with a string
* relative path.
*/
public static TreeFileArtifact createTreeOutput(
SpecialArtifact parent, String parentRelativePath) {
return createTreeOutput(parent, PathFragment.create(parentRelativePath));
}
/**
* Creates a {@link TreeFileArtifact} representing the output of an action generated dynamically
* by an {@link ActionTemplate} during the execution phase.
*
* The returned artifact does not yet have a generating action set.
*/
public static TreeFileArtifact createTemplateExpansionOutput(
SpecialArtifact parent, PathFragment parentRelativePath, ActionLookupKey owner) {
Preconditions.checkArgument(
isActionTemplateExpansionKey(owner),
"Template expansion outputs must be owned by an action template expansion key, but %s is"
+ " owned by %s (parent relative path: %s)",
parent,
owner,
parentRelativePath);
return new TreeFileArtifact(parent, parentRelativePath, owner);
}
/**
* Convenience method for {@link #createTemplateExpansionOutput(SpecialArtifact, PathFragment,
* ActionLookupKey)} with a string relative path.
*/
public static TreeFileArtifact createTemplateExpansionOutput(
SpecialArtifact parent, String parentRelativePath, ActionLookupKey owner) {
return createTemplateExpansionOutput(parent, PathFragment.create(parentRelativePath), owner);
}
private TreeFileArtifact(
SpecialArtifact parent, PathFragment parentRelativePath, Object owner) {
super(parent.getRoot(), parent.getExecPath().getRelative(parentRelativePath), owner);
Preconditions.checkArgument(
parent.isTreeArtifact(),
"The parent of TreeFileArtifact (parent-relative path: %s) is not a TreeArtifact: %s",
parentRelativePath,
parent);
Preconditions.checkArgument(
!parentRelativePath.containsUplevelReferences() && !parentRelativePath.isAbsolute(),
"%s is not a proper normalized relative path",
parentRelativePath);
this.parent = parent;
this.parentRelativePath = parentRelativePath;
}
@Override
public SpecialArtifact getParent() {
return parent;
}
@Override
public PathFragment getParentRelativePath() {
return parentRelativePath;
}
@Override
public String getTreeRelativePathString() {
return parentRelativePath.getPathString();
}
@Override
public boolean isChildOfDeclaredDirectory() {
return !isActionTemplateExpansionKey(getArtifactOwner());
}
private static boolean isActionTemplateExpansionKey(ActionLookupKey key) {
return SkyFunctions.ACTION_TEMPLATE_EXPANSION.equals(key.functionName());
}
}
@SuppressWarnings("unused") // Used by reflection.
private static final class TreeFileArtifactCodec implements ObjectCodec Avoid this method in production code - it flattens the given nested set unconditionally.
*/
@VisibleForTesting
public static List A middleman artifact is never added to the collection. If {@code keepEmptyTreeArtifacts} is
* true, a tree artifact will be added to the collection when it expands into zero file artifacts.
* Otherwise, only the file artifacts the tree artifact expands into will be added.
*/
static void addExpandedArtifact(
Artifact artifact,
Collection output,
ArtifactExpander artifactExpander,
boolean keepEmptyTreeArtifacts) {
if (artifact.isMiddlemanArtifact() || artifact.isTreeArtifact()) {
List
*
*/
public static final class TreeFileArtifact extends DerivedArtifact {
private final SpecialArtifact parent;
private final PathFragment parentRelativePath;
/**
* Creates a {@link TreeFileArtifact} representing a child of the given parent tree artifact.
*
*