/*
* Copyright 2015-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package com.facebook.buck.rules.keys;
import com.facebook.buck.rules.BuildContext;
import com.facebook.buck.rules.BuildRule;
import com.facebook.buck.rules.SourcePath;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.util.function.Predicate;
/** Used to tag a rule that supports dependency-file input-based rule keys. */
public interface SupportsDependencyFileRuleKey extends BuildRule {
boolean useDependencyFileRuleKeys();
/**
* Returns a predicate that can tell whether a given path is covered by dep-file or not. Note that
* being covered by dep-file doesn't necessarily mean being present in the dep-file. A covered
* path will only be present if actually used and that's the core idea of dep-file keys.
*
* <p>I.e. this predicate should return true only for source paths that *may* be returned from
* {@link #getInputsAfterBuildingLocally(BuildContext)}. This information is used by the rule key
* builder to infer that inputs *not* in this list should be included unconditionally in the rule
* key. Inputs that *are* in this list should be included in the rule key if and only if they are
* actually being used for the rule. I.e. if they are present in the dep-file listed by {@link
* #getInputsAfterBuildingLocally(BuildContext)}.
*/
Predicate<SourcePath> getCoveredByDepFilePredicate();
/**
* Returns a predicate that can tell whether the existence of a given path may be of interest to
* compiler. If this predicate returns true, the path should be included in the rule key. Note
* that we only care about the existence here. The actual content of the file is not relevant.
*
* <p>The main purpose of this predicate is to support scenarios where compiler decides whether to
* use a file or not solely based on its path. Of course, if compiler decides to use the file, it
* should list it in the dep-file in which case both the path and the content will be included in
* the rule key. However, relying only on presence in the dep-file for such paths is not
* sufficient. The problem occurs when a new such file just gets added, in which case it won't be
* present in the dep-file produced in the previous build, and yet if we run a local build now the
* compiler may decide to use it. For that reason rule key needs to reflect existence of all such
* files and change when a such a file gets added or removed.
*/
Predicate<SourcePath> getExistenceOfInterestPredicate();
/**
* Returns a list of source paths that were actually used for the rule. This list comes from the
* dep-file produced by compiler.
*/
ImmutableList<SourcePath> getInputsAfterBuildingLocally(BuildContext context) throws IOException;
}