/**
* A not type safe constructor for SkylarkNestedSet. It's discouraged to use it unless type
* generic safety is guaranteed from the caller side.
*/
SkylarkNestedSet(SkylarkType contentType, NestedSet<?> set) {
// This is here for the sake of FuncallExpression.
this.contentType = Preconditions.checkNotNull(contentType, "type cannot be null");
this.set = Preconditions.checkNotNull(set, "set cannot be null");
this.items = null;
this.transitiveItems = null;
}
public CcLibraryHelper(
RuleContext ruleContext, CppSemantics semantics, FeatureConfiguration featureConfiguration) {
this.ruleContext = Preconditions.checkNotNull(ruleContext);
this.configuration = ruleContext.getConfiguration();
this.semantics = Preconditions.checkNotNull(semantics);
this.featureConfiguration = Preconditions.checkNotNull(featureConfiguration);
}
IntermediateArtifacts(
RuleContext ruleContext,
String archiveFileNameSuffix,
String outputPrefix,
BuildConfiguration buildConfiguration) {
this.ruleContext = ruleContext;
this.buildConfiguration = buildConfiguration;
this.archiveFileNameSuffix = Preconditions.checkNotNull(archiveFileNameSuffix);
this.outputPrefix = Preconditions.checkNotNull(outputPrefix);
}
public CppModel(RuleContext ruleContext, CppSemantics semantics) {
this.ruleContext = Preconditions.checkNotNull(ruleContext);
this.semantics = semantics;
configuration = ruleContext.getConfiguration();
cppConfiguration = ruleContext.getFragment(CppConfiguration.class);
features = CppHelper.getToolchain(ruleContext).getFeatures();
}
private NodeEntry getEntryForValue(SkyKey key) {
NodeEntry entry =
Preconditions.checkNotNull(
graph.getBatch(null, Reason.WALKABLE_GRAPH_VALUE, ImmutableList.of(key)).get(key), key);
Preconditions.checkState(entry.isDone(), "%s %s", key, entry);
return entry;
}
/**
* Create a GlobValue wrapping {@code matches}. {@code matches} must have order {@link
* Order#STABLE_ORDER}.
*/
public GlobValue(NestedSet<PathFragment> matches) {
this.matches = Preconditions.checkNotNull(matches);
Preconditions.checkState(
matches.getOrder() == Order.STABLE_ORDER,
"Only STABLE_ORDER is supported, but got %s",
matches.getOrder());
}
/**
* Merges the context of a dependency into this one by adding the contents of all of its
* attributes.
*/
public Builder mergeDependentContext(CppCompilationContext otherContext) {
Preconditions.checkNotNull(otherContext);
compilationPrerequisites.addAll(otherContext.getTransitiveCompilationPrerequisites());
includeDirs.addAll(otherContext.getIncludeDirs());
quoteIncludeDirs.addAll(otherContext.getQuoteIncludeDirs());
systemIncludeDirs.addAll(otherContext.getSystemIncludeDirs());
declaredIncludeDirs.addTransitive(otherContext.getDeclaredIncludeDirs());
declaredIncludeWarnDirs.addTransitive(otherContext.getDeclaredIncludeWarnDirs());
declaredIncludeSrcs.addTransitive(otherContext.getDeclaredIncludeSrcs());
pregreppedHdrs.addTransitive(otherContext.getPregreppedHeaders());
moduleInfo.addTransitive(otherContext.moduleInfo);
picModuleInfo.addTransitive(otherContext.picModuleInfo);
NestedSet<Artifact> othersTransitiveModuleMaps = otherContext.getTransitiveModuleMaps();
NestedSet<Artifact> othersDirectModuleMaps = otherContext.getDirectModuleMaps();
// Forward transitive information.
// The other target's transitive module maps do not include its direct module maps, so we
// add both.
transitiveModuleMaps.addTransitive(othersTransitiveModuleMaps);
transitiveModuleMaps.addTransitive(othersDirectModuleMaps);
// All module maps of direct dependencies are inputs to the current compile independently of
// the build type.
if (otherContext.getCppModuleMap() != null) {
directModuleMaps.add(otherContext.getCppModuleMap().getArtifact());
}
defines.addAll(otherContext.getDefines());
return this;
}
private void init() throws InterruptedException {
EvaluationResult<SkyValue> result;
try (AutoProfiler p = AutoProfiler.logged("evaluation and walkable graph", LOG)) {
result =
graphFactory.prepareAndGet(
universeScope, parserPrefix, loadingPhaseThreads, eventHandler);
}
graph = result.getWalkableGraph();
SkyKey universeKey = graphFactory.getUniverseKey(universeScope, parserPrefix);
universeTargetPatternKeys =
PrepareDepsOfPatternsFunction.getTargetPatternKeys(
PrepareDepsOfPatternsFunction.getSkyKeys(universeKey, eventHandler));
// The prepareAndGet call above evaluates a single PrepareDepsOfPatterns SkyKey.
// We expect to see either a single successfully evaluated value or a cycle in the result.
Collection<SkyValue> values = result.values();
if (!values.isEmpty()) {
Preconditions.checkState(
values.size() == 1,
"Universe query \"%s\" returned multiple" + " values unexpectedly (%s values in result)",
universeScope,
values.size());
Preconditions.checkNotNull(result.get(universeKey), result);
} else {
// No values in the result, so there must be an error. We expect the error to be a cycle.
boolean foundCycle = !Iterables.isEmpty(result.getError().getCycleInfo());
Preconditions.checkState(
foundCycle,
"Universe query \"%s\" failed with non-cycle error: %s",
universeScope,
result.getError());
}
}
private CppCompilationContext(
CommandLineContext commandLineContext,
ImmutableSet<Artifact> compilationPrerequisites,
NestedSet<PathFragment> declaredIncludeDirs,
NestedSet<PathFragment> declaredIncludeWarnDirs,
NestedSet<Artifact> declaredIncludeSrcs,
NestedSet<Pair<Artifact, Artifact>> pregreppedHdrs,
ModuleInfo moduleInfo,
ModuleInfo picModuleInfo,
NestedSet<Artifact> transitiveModuleMaps,
NestedSet<Artifact> directModuleMaps,
CppModuleMap cppModuleMap,
boolean provideTransitiveModuleMaps,
boolean useHeaderModules) {
Preconditions.checkNotNull(commandLineContext);
this.commandLineContext = commandLineContext;
this.declaredIncludeDirs = declaredIncludeDirs;
this.declaredIncludeWarnDirs = declaredIncludeWarnDirs;
this.declaredIncludeSrcs = declaredIncludeSrcs;
this.directModuleMaps = directModuleMaps;
this.pregreppedHdrs = pregreppedHdrs;
this.moduleInfo = moduleInfo;
this.picModuleInfo = picModuleInfo;
this.transitiveModuleMaps = transitiveModuleMaps;
this.cppModuleMap = cppModuleMap;
this.provideTransitiveModuleMaps = provideTransitiveModuleMaps;
this.useHeaderModules = useHeaderModules;
this.compilationPrerequisites = compilationPrerequisites;
}
/**
* Returns the configurable attribute conditions necessary to evaluate the given configured
* target, or null if not all dependencies have yet been SkyFrame-evaluated.
*/
@Nullable
private Set<ConfigMatchingProvider> getConfigurableAttributeConditions(
TargetAndConfiguration ctg, Environment env) {
if (!(ctg.getTarget() instanceof Rule)) {
return ImmutableSet.of();
}
Rule rule = (Rule) ctg.getTarget();
RawAttributeMapper mapper = RawAttributeMapper.of(rule);
Set<SkyKey> depKeys = new LinkedHashSet<>();
for (Attribute attribute : rule.getAttributes()) {
for (Label label : mapper.getConfigurabilityKeys(attribute.getName(), attribute.getType())) {
if (!BuildType.Selector.isReservedLabel(label)) {
depKeys.add(ConfiguredTargetValue.key(label, ctg.getConfiguration()));
}
}
}
Map<SkyKey, SkyValue> cts = env.getValues(depKeys);
if (env.valuesMissing()) {
return null;
}
ImmutableSet.Builder<ConfigMatchingProvider> conditions = ImmutableSet.builder();
for (SkyValue ctValue : cts.values()) {
ConfiguredTarget ct = ((ConfiguredTargetValue) ctValue).getConfiguredTarget();
conditions.add(Preconditions.checkNotNull(ct.getProvider(ConfigMatchingProvider.class)));
}
return conditions.build();
}
/** Exits a scope by restoring state from the current continuation */
void exitScope() {
Preconditions.checkNotNull(continuation);
lexicalFrame = continuation.lexicalFrame;
globalFrame = continuation.globalFrame;
knownGlobalVariables = continuation.knownGlobalVariables;
isSkylark = continuation.isSkylark;
continuation = continuation.continuation;
}
/**
* Returns just the .params file portion of the command-line as a {@link CommandLine}.
*
* @throws IllegalStateException if the command-line cannot be split
*/
CommandLine paramCmdLine() {
Preconditions.checkNotNull(paramFile);
return new CommandLine() {
@Override
public Iterable<String> arguments() {
return splitCommandline().getSecond();
}
};
}
@Nullable
private AspectValue createAspect(
Environment env,
AspectKey key,
ConfiguredAspectFactory aspectFactory,
RuleConfiguredTarget associatedTarget,
Set<ConfigMatchingProvider> configConditions,
ListMultimap<Attribute, ConfiguredTarget> directDeps,
NestedSetBuilder<Package> transitivePackages)
throws AspectFunctionException, InterruptedException {
SkyframeBuildView view = buildViewProvider.getSkyframeBuildView();
BuildConfiguration configuration = associatedTarget.getConfiguration();
StoredEventHandler events = new StoredEventHandler();
CachingAnalysisEnvironment analysisEnvironment =
view.createAnalysisEnvironment(key, false, events, env, configuration);
if (env.valuesMissing()) {
return null;
}
ConfiguredAspect configuredAspect =
view.getConfiguredTargetFactory()
.createAspect(
analysisEnvironment,
associatedTarget,
aspectFactory,
key.getAspect(),
directDeps,
configConditions,
view.getHostConfiguration(associatedTarget.getConfiguration()));
events.replayOn(env.getListener());
if (events.hasErrors()) {
analysisEnvironment.disable(associatedTarget.getTarget());
throw new AspectFunctionException(
new AspectCreationException(
"Analysis of target '" + associatedTarget.getLabel() + "' failed; build aborted"));
}
Preconditions.checkState(
!analysisEnvironment.hasErrors(), "Analysis environment hasError() but no errors reported");
if (env.valuesMissing()) {
return null;
}
analysisEnvironment.disable(associatedTarget.getTarget());
Preconditions.checkNotNull(configuredAspect);
return new AspectValue(
key,
associatedTarget.getLabel(),
associatedTarget.getTarget().getLocation(),
configuredAspect,
ImmutableList.copyOf(analysisEnvironment.getRegisteredActions()),
transitivePackages.build());
}
/**
* Constructs an Environment. This is the main, most basic constructor.
*
* @param globalFrame a frame for the global Environment
* @param dynamicFrame a frame for the dynamic Environment
* @param eventHandler an EventHandler for warnings, errors, etc
* @param importedExtensions Extension-s from which to import bindings with load()
* @param isSkylark true if in Skylark context
* @param fileContentHashCode a hash for the source file being evaluated, if any
* @param isLoadingPhase true if in loading phase
*/
private Environment(
Frame globalFrame,
Frame dynamicFrame,
EventHandler eventHandler,
Map<String, Extension> importedExtensions,
boolean isSkylark,
@Nullable String fileContentHashCode,
boolean isLoadingPhase) {
this.globalFrame = Preconditions.checkNotNull(globalFrame);
this.dynamicFrame = Preconditions.checkNotNull(dynamicFrame);
Preconditions.checkArgument(globalFrame.mutability().isMutable());
Preconditions.checkArgument(dynamicFrame.mutability().isMutable());
this.eventHandler = eventHandler;
this.importedExtensions = importedExtensions;
this.isSkylark = isSkylark;
this.fileContentHashCode = fileContentHashCode;
this.isLoadingPhase = isLoadingPhase;
}
/**
* Returns a hash code calculated from the hash code of this Environment and the transitive
* closure of other Environments it loads.
*/
public String getTransitiveContentHashCode() {
// Calculate a new hash from the hash of the loaded Extension-s.
Fingerprint fingerprint = new Fingerprint();
fingerprint.addString(Preconditions.checkNotNull(fileContentHashCode));
TreeSet<String> importStrings = new TreeSet<>(importedExtensions.keySet());
for (String importString : importStrings) {
fingerprint.addString(importedExtensions.get(importString).getTransitiveContentHashCode());
}
return fingerprint.hexDigestAndReset();
}
@Override
public void process(Iterable<Target> partialResult)
throws QueryException, InterruptedException {
Preconditions.checkNotNull(pending, "Reuse of the callback is not allowed");
pending.addAll(uniquifier.unique(partialResult));
if (pending.size() >= batchThreshold) {
callback.process(pending);
pending = new ArrayList<>();
}
}
FakeCppCompileAction(
ActionOwner owner,
ImmutableList<String> features,
FeatureConfiguration featureConfiguration,
CcToolchainFeatures.Variables variables,
Artifact sourceFile,
boolean shouldScanIncludes,
Label sourceLabel,
NestedSet<Artifact> mandatoryInputs,
Artifact outputFile,
PathFragment tempOutputFile,
DotdFile dotdFile,
BuildConfiguration configuration,
CppConfiguration cppConfiguration,
CppCompilationContext context,
Class<? extends CppCompileActionContext> actionContext,
ImmutableList<String> copts,
Predicate<String> nocopts,
RuleContext ruleContext) {
super(
owner,
features,
featureConfiguration,
variables,
sourceFile,
shouldScanIncludes,
sourceLabel,
mandatoryInputs,
outputFile,
dotdFile,
null,
null,
null,
configuration,
cppConfiguration,
// We only allow inclusion of header files explicitly declared in
// "srcs", so we only use declaredIncludeSrcs, not declaredIncludeDirs.
// (Disallowing use of undeclared headers for cc_fake_binary is needed
// because the header files get included in the runfiles for the
// cc_fake_binary and for the negative compilation tests that depend on
// the cc_fake_binary, and the runfiles must be determined at analysis
// time, so they can't depend on the contents of the ".d" file.)
CppCompilationContext.disallowUndeclaredHeaders(context),
actionContext,
copts,
nocopts,
VOID_SPECIAL_INPUTS_HANDLER,
ImmutableList.<IncludeScannable>of(),
GUID,
ImmutableSet.<String>of(),
CppCompileAction.CPP_COMPILE,
ruleContext);
this.tempOutputFile = Preconditions.checkNotNull(tempOutputFile);
}
private XcodeProvider(Builder builder) {
this.label = Preconditions.checkNotNull(builder.label);
this.propagatedUserHeaderSearchPaths = builder.propagatedUserHeaderSearchPaths.build();
this.nonPropagatedUserHeaderSearchPaths = builder.nonPropagatedUserHeaderSearchPaths.build();
this.propagatedHeaderSearchPaths = builder.propagatedHeaderSearchPaths.build();
this.nonPropagatedHeaderSearchPaths = builder.nonPropagatedHeaderSearchPaths.build();
this.bundleInfoplist = builder.bundleInfoplist;
this.propagatedDependencies = builder.propagatedDependencies.build();
this.nonPropagatedDependencies = builder.nonPropagatedDependencies.build();
this.jreDependencies = builder.jreDependencies.build();
this.xcodeprojBuildSettings = builder.xcodeprojBuildSettings.build();
this.companionTargetXcodeprojBuildSettings =
builder.companionTargetXcodeprojBuildSettings.build();
this.copts = builder.copts.build();
this.compilationModeCopts = builder.compilationModeCopts.build();
this.productType = Preconditions.checkNotNull(builder.productType);
this.headers = builder.headers.build();
this.compilationArtifacts = builder.compilationArtifacts;
this.objcProvider = Preconditions.checkNotNull(builder.objcProvider);
this.testHost = Preconditions.checkNotNull(builder.testHost);
this.inputsToXcodegen = builder.inputsToXcodegen.build();
this.additionalSources = builder.additionalSources.build();
this.extensions = builder.extensions.build();
this.architecture = Preconditions.checkNotNull(builder.architecture);
this.generateCompanionLibTarget = builder.generateCompanionLibTarget;
this.configurationDistinguisher =
Preconditions.checkNotNull(builder.configurationDistinguisher);
}
/**
* Invokes the appropriate constructor to create a {@link ConfiguredTarget} instance.
*
* <p>For use in {@code ConfiguredTargetFunction}.
*
* <p>Returns null if Skyframe deps are missing or upon certain errors.
*/
@Nullable
ConfiguredTarget createConfiguredTarget(
Target target,
BuildConfiguration configuration,
CachingAnalysisEnvironment analysisEnvironment,
ListMultimap<Attribute, ConfiguredTarget> prerequisiteMap,
Set<ConfigMatchingProvider> configConditions)
throws InterruptedException {
Preconditions.checkState(
enableAnalysis, "Already in execution phase %s %s", target, configuration);
Preconditions.checkNotNull(analysisEnvironment);
Preconditions.checkNotNull(target);
Preconditions.checkNotNull(prerequisiteMap);
return factory.createConfiguredTarget(
analysisEnvironment,
artifactFactory,
target,
configuration,
getHostConfiguration(configuration),
prerequisiteMap,
configConditions);
}
/**
* Creates and returns a rule instance.
*
* <p>It is the caller's responsibility to add the rule to the package (the caller may choose not
* to do so if, for example, the rule has errors).
*/
static Rule createRule(
Package.Builder pkgBuilder,
RuleClass ruleClass,
BuildLangTypedAttributeValuesMap attributeValues,
EventHandler eventHandler,
@Nullable FuncallExpression ast,
Location location,
@Nullable Environment env)
throws InvalidRuleException, InterruptedException {
Preconditions.checkNotNull(ruleClass);
String ruleClassName = ruleClass.getName();
Object nameObject = attributeValues.getAttributeValue("name");
if (nameObject == null) {
throw new InvalidRuleException(ruleClassName + " rule has no 'name' attribute");
} else if (!(nameObject instanceof String)) {
throw new InvalidRuleException(ruleClassName + " 'name' attribute must be a string");
}
String name = (String) nameObject;
Label label;
try {
// Test that this would form a valid label name -- in particular, this
// catches cases where Makefile variables $(foo) appear in "name".
label = pkgBuilder.createLabel(name);
} catch (LabelSyntaxException e) {
throw new InvalidRuleException("illegal rule name: " + name + ": " + e.getMessage());
}
boolean inWorkspaceFile = pkgBuilder.isWorkspace();
if (ruleClass.getWorkspaceOnly() && !inWorkspaceFile) {
throw new RuleFactory.InvalidRuleException(
ruleClass + " must be in the WORKSPACE file " + "(used by " + label + ")");
} else if (!ruleClass.getWorkspaceOnly() && inWorkspaceFile) {
throw new RuleFactory.InvalidRuleException(
ruleClass + " cannot be in the WORKSPACE file " + "(used by " + label + ")");
}
AttributesAndLocation generator =
generatorAttributesForMacros(attributeValues, env, location, label);
try {
return ruleClass.createRule(
pkgBuilder,
label,
generator.attributes,
eventHandler,
ast,
generator.location,
new AttributeContainer(ruleClass));
} catch (LabelSyntaxException e) {
throw new RuleFactory.InvalidRuleException(ruleClass + " " + e.getMessage());
}
}
private WalkableGraph getGraphFromPatternsEvaluation(
ImmutableList<String> patternSequence, boolean successExpected, boolean keepGoing)
throws InterruptedException {
SkyKey independentTarget = PrepareDepsOfPatternsValue.key(patternSequence, "");
ImmutableList<SkyKey> singletonTargetPattern = ImmutableList.of(independentTarget);
// When PrepareDepsOfPatternsFunction completes evaluation,
EvaluationResult<SkyValue> evaluationResult =
getSkyframeExecutor()
.getDriverForTesting()
.evaluate(singletonTargetPattern, keepGoing, LOADING_PHASE_THREADS, eventCollector);
// The evaluation has no errors if success was expected.
assertThat(evaluationResult.hasError()).isNotEqualTo(successExpected);
return Preconditions.checkNotNull(evaluationResult.getWalkableGraph());
}
/**
* Modifies a binding in the current Frame of this Environment, as would an {@link
* AssignmentStatement}. Does not try to modify an inherited binding. This will shadow any
* inherited binding, which may be an error that you want to guard against before calling this
* function.
*
* @param varname the name of the variable to be bound
* @param value the value to bind to the variable
* @return this Environment, in fluid style
*/
public Environment update(String varname, Object value) throws EvalException {
Preconditions.checkNotNull(value, "update(value == null)");
// prevents clashes between static and dynamic variables.
if (dynamicFrame.get(varname) != null) {
throw new EvalException(
null, String.format("Trying to update special read-only global variable '%s'", varname));
}
if (isKnownGlobalVariable(varname)) {
throw new EvalException(
null, String.format("Trying to update read-only global variable '%s'", varname));
}
try {
currentFrame().put(this, varname, Preconditions.checkNotNull(value));
} catch (MutabilityException e) {
// Note that since at this time we don't accept the global keyword, and don't have closures,
// end users should never be able to mutate a frozen Environment, and a MutabilityException
// is therefore a failed assertion for Bazel. However, it is possible to shadow a binding
// imported from a parent Environment by updating the current Environment, which will not
// trigger a MutabilityException.
throw new AssertionError(
Printer.format("Can't update %s to %r in frozen environment", varname, value), e);
}
return this;
}
@Override
protected void preloadOrThrow(QueryExpression caller, Collection<String> patterns)
throws QueryException, TargetParsingException {
Map<String, SkyKey> keys = new HashMap<>(patterns.size());
for (String pattern : patterns) {
try {
keys.put(
pattern,
TargetPatternValue.key(
pattern, TargetPatternEvaluator.DEFAULT_FILTERING_POLICY, parserPrefix));
} catch (TargetParsingException e) {
reportBuildFileError(caller, e.getMessage());
}
}
// Get all the patterns in one batch call
Map<SkyKey, SkyValue> existingPatterns = graph.getSuccessfulValues(keys.values());
for (String pattern : patterns) {
SkyKey patternKey = keys.get(pattern);
if (patternKey == null) {
// Exception was thrown when creating key above. Skip.
continue;
}
TargetParsingException targetParsingException = null;
if (existingPatterns.containsKey(patternKey)) {
// The graph already contains a value or exception for this target pattern, so we use it.
TargetPatternValue value = (TargetPatternValue) existingPatterns.get(patternKey);
if (value != null) {
precomputedPatterns.put(pattern, value.getTargets().getTargets());
} else {
// Because the graph was always initialized via a keep_going build, we know that the
// exception stored here must be a TargetParsingException. Thus the comment in
// SkyframeTargetPatternEvaluator#parseTargetPatternKeys describing the situation in which
// the exception acceptance must be looser does not apply here.
targetParsingException =
(TargetParsingException)
Preconditions.checkNotNull(graph.getException(patternKey), pattern);
}
}
if (targetParsingException != null) {
reportBuildFileError(caller, targetParsingException.getMessage());
}
}
}
// This is safe because of the type checking
@SuppressWarnings("unchecked")
private SkylarkNestedSet(
Order order,
SkylarkType contentType,
Object item,
Location loc,
List<Object> items,
List<NestedSet<Object>> transitiveItems)
throws EvalException {
// Adding the item
if (item instanceof SkylarkNestedSet) {
SkylarkNestedSet nestedSet = (SkylarkNestedSet) item;
if (!nestedSet.isEmpty()) {
contentType = checkType(contentType, nestedSet.contentType, loc);
transitiveItems.add((NestedSet<Object>) nestedSet.set);
}
} else if (item instanceof SkylarkList) {
// TODO(bazel-team): we should check ImmutableList here but it screws up genrule at line 43
for (Object object : (SkylarkList) item) {
contentType = checkType(contentType, SkylarkType.of(object.getClass()), loc);
checkImmutable(object, loc);
items.add(object);
}
} else {
throw new EvalException(
loc,
String.format("cannot add value of type '%s' to a set", EvalUtils.getDataTypeName(item)));
}
this.contentType = Preconditions.checkNotNull(contentType, "type cannot be null");
// Initializing the real nested set
NestedSetBuilder<Object> builder = new NestedSetBuilder<>(order);
builder.addAll(items);
try {
for (NestedSet<Object> nestedSet : transitiveItems) {
builder.addTransitive(nestedSet);
}
} catch (IllegalStateException e) {
throw new EvalException(loc, e.getMessage());
}
this.set = builder.build();
this.items = ImmutableList.copyOf(items);
this.transitiveItems = ImmutableList.copyOf(transitiveItems);
}
public SkyQueryEnvironment(
boolean keepGoing,
boolean strictScope,
int loadingPhaseThreads,
Predicate<Label> labelFilter,
EventHandler eventHandler,
Set<Setting> settings,
Iterable<QueryFunction> extraFunctions,
String parserPrefix,
WalkableGraphFactory graphFactory,
List<String> universeScope,
PathPackageLocator pkgPath) {
super(keepGoing, strictScope, labelFilter, eventHandler, settings, extraFunctions);
this.loadingPhaseThreads = loadingPhaseThreads;
this.graphFactory = graphFactory;
this.pkgPath = pkgPath;
this.universeScope = Preconditions.checkNotNull(universeScope);
this.parserPrefix = parserPrefix;
Preconditions.checkState(
!universeScope.isEmpty(), "No queries can be performed with an empty universe");
}
@Override
public Target getTarget(Label label) throws TargetNotFoundException, QueryException {
SkyKey packageKey = getPackageKeyAndValidateLabel(label);
if (!graph.exists(packageKey)) {
throw new QueryException(packageKey + " does not exist in graph");
}
try {
PackageValue packageValue = (PackageValue) graph.getValue(packageKey);
if (packageValue != null) {
Package pkg = packageValue.getPackage();
if (pkg.containsErrors()) {
throw new BuildFileContainsErrorsException(label.getPackageIdentifier());
}
return packageValue.getPackage().getTarget(label.getName());
} else {
throw (NoSuchThingException)
Preconditions.checkNotNull(graph.getException(packageKey), label);
}
} catch (NoSuchThingException e) {
throw new TargetNotFoundException(e);
}
}
public HashLine(char[] buffer, PathFragment defaultPath) {
CharSequence bufString = CharBuffer.wrap(buffer);
Matcher m = pattern.matcher(bufString);
List<SingleHashLine> unorderedTable = new ArrayList<>();
Map<String, PathFragment> pathCache = new HashMap<>();
while (m.find()) {
String pathString = m.group(2);
PathFragment pathFragment = pathCache.get(pathString);
if (pathFragment == null) {
pathFragment = defaultPath.getRelative(pathString);
pathCache.put(pathString, pathFragment);
}
unorderedTable.add(
new SingleHashLine(
m.start(0) + 1, // offset (+1 to skip \n in pattern)
Integer.parseInt(m.group(1)), // line number
pathFragment)); // filename is an absolute path
}
this.table = hashOrdering.immutableSortedCopy(unorderedTable);
this.bufferLength = buffer.length;
this.defaultPath = Preconditions.checkNotNull(defaultPath);
}
@Override
public ConfiguredTarget create(RuleContext ruleContext)
throws RuleErrorException, InterruptedException {
TransitiveInfoCollection lipoContextCollector =
ruleContext.getPrerequisite(":lipo_context_collector", Mode.DONT_CHECK);
if (lipoContextCollector != null
&& lipoContextCollector.getProvider(LipoContextProvider.class) == null) {
ruleContext.ruleError("--lipo_context must point to a cc_binary or a cc_test rule");
return null;
}
CppConfiguration cppConfiguration =
Preconditions.checkNotNull(ruleContext.getFragment(CppConfiguration.class));
Path fdoZip =
ruleContext.getConfiguration().getCompilationMode() == CompilationMode.OPT
? cppConfiguration.getFdoZip()
: null;
SkyKey fdoKey =
FdoSupportValue.key(
cppConfiguration.getLipoMode(), fdoZip, cppConfiguration.getFdoInstrument());
SkyFunction.Environment skyframeEnv = ruleContext.getAnalysisEnvironment().getSkyframeEnv();
FdoSupportValue fdoSupport;
try {
fdoSupport =
(FdoSupportValue)
skyframeEnv.getValueOrThrow(fdoKey, FdoException.class, IOException.class);
} catch (FdoException | IOException e) {
ruleContext.ruleError("cannot initialize FDO: " + e.getMessage());
return null;
}
if (skyframeEnv.valuesMissing()) {
return null;
}
final Label label = ruleContext.getLabel();
final NestedSet<Artifact> crosstool =
ruleContext
.getPrerequisite("all_files", Mode.HOST)
.getProvider(FileProvider.class)
.getFilesToBuild();
final NestedSet<Artifact> crosstoolMiddleman = getFiles(ruleContext, "all_files");
final NestedSet<Artifact> compile = getFiles(ruleContext, "compiler_files");
final NestedSet<Artifact> strip = getFiles(ruleContext, "strip_files");
final NestedSet<Artifact> objcopy = getFiles(ruleContext, "objcopy_files");
final NestedSet<Artifact> link = getFiles(ruleContext, "linker_files");
final NestedSet<Artifact> dwp = getFiles(ruleContext, "dwp_files");
final NestedSet<Artifact> libcLink = inputsForLibc(ruleContext);
String purposePrefix = Actions.escapeLabel(label) + "_";
String runtimeSolibDirBase = "_solib_" + "_" + Actions.escapeLabel(label);
final PathFragment runtimeSolibDir =
ruleContext.getConfiguration().getBinFragment().getRelative(runtimeSolibDirBase);
// Static runtime inputs.
TransitiveInfoCollection staticRuntimeLibDep =
selectDep(ruleContext, "static_runtime_libs", cppConfiguration.getStaticRuntimeLibsLabel());
final NestedSet<Artifact> staticRuntimeLinkInputs;
final Artifact staticRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
staticRuntimeLinkInputs =
staticRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild();
} else {
staticRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!staticRuntimeLinkInputs.isEmpty()) {
NestedSet<Artifact> staticRuntimeLinkMiddlemanSet =
CompilationHelper.getAggregatingMiddleman(
ruleContext, purposePrefix + "static_runtime_link", staticRuntimeLibDep);
staticRuntimeLinkMiddleman =
staticRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(staticRuntimeLinkMiddlemanSet);
} else {
staticRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(staticRuntimeLinkMiddleman == null) == staticRuntimeLinkInputs.isEmpty());
// Dynamic runtime inputs.
TransitiveInfoCollection dynamicRuntimeLibDep =
selectDep(
ruleContext, "dynamic_runtime_libs", cppConfiguration.getDynamicRuntimeLibsLabel());
final NestedSet<Artifact> dynamicRuntimeLinkInputs;
final Artifact dynamicRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
NestedSetBuilder<Artifact> dynamicRuntimeLinkInputsBuilder = NestedSetBuilder.stableOrder();
for (Artifact artifact :
dynamicRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild()) {
if (CppHelper.SHARED_LIBRARY_FILETYPES.matches(artifact.getFilename())) {
dynamicRuntimeLinkInputsBuilder.add(
SolibSymlinkAction.getCppRuntimeSymlink(
ruleContext, artifact, runtimeSolibDirBase, ruleContext.getConfiguration()));
} else {
dynamicRuntimeLinkInputsBuilder.add(artifact);
}
}
dynamicRuntimeLinkInputs = dynamicRuntimeLinkInputsBuilder.build();
} else {
dynamicRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!dynamicRuntimeLinkInputs.isEmpty()) {
List<Artifact> dynamicRuntimeLinkMiddlemanSet =
CppHelper.getAggregatingMiddlemanForCppRuntimes(
ruleContext,
purposePrefix + "dynamic_runtime_link",
dynamicRuntimeLibDep,
runtimeSolibDirBase,
ruleContext.getConfiguration());
dynamicRuntimeLinkMiddleman =
dynamicRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(dynamicRuntimeLinkMiddlemanSet);
} else {
dynamicRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(dynamicRuntimeLinkMiddleman == null) == dynamicRuntimeLinkInputs.isEmpty());
CppCompilationContext.Builder contextBuilder = new CppCompilationContext.Builder(ruleContext);
CppModuleMap moduleMap = createCrosstoolModuleMap(ruleContext);
if (moduleMap != null) {
contextBuilder.setCppModuleMap(moduleMap);
}
final CppCompilationContext context = contextBuilder.build();
boolean supportsParamFiles = ruleContext.attributes().get("supports_param_files", BOOLEAN);
boolean supportsHeaderParsing =
ruleContext.attributes().get("supports_header_parsing", BOOLEAN);
NestedSetBuilder<Pair<String, String>> coverageEnvironment = NestedSetBuilder.compileOrder();
coverageEnvironment.add(
Pair.of("COVERAGE_GCOV_PATH", cppConfiguration.getGcovExecutable().getPathString()));
if (cppConfiguration.getFdoInstrument() != null) {
coverageEnvironment.add(
Pair.of("FDO_DIR", cppConfiguration.getFdoInstrument().getPathString()));
}
CcToolchainProvider provider =
new CcToolchainProvider(
cppConfiguration,
crosstool,
fullInputsForCrosstool(ruleContext, crosstoolMiddleman),
compile,
strip,
objcopy,
fullInputsForLink(ruleContext, link),
dwp,
libcLink,
staticRuntimeLinkInputs,
staticRuntimeLinkMiddleman,
dynamicRuntimeLinkInputs,
dynamicRuntimeLinkMiddleman,
runtimeSolibDir,
context,
supportsParamFiles,
supportsHeaderParsing,
getBuildVariables(ruleContext),
getBuiltinIncludes(ruleContext),
coverageEnvironment.build());
RuleConfiguredTargetBuilder builder =
new RuleConfiguredTargetBuilder(ruleContext)
.add(CcToolchainProvider.class, provider)
.add(FdoSupportProvider.class, new FdoSupportProvider(fdoSupport.getFdoSupport()))
.setFilesToBuild(new NestedSetBuilder<Artifact>(Order.STABLE_ORDER).build())
.add(RunfilesProvider.class, RunfilesProvider.simple(Runfiles.EMPTY));
// If output_license is specified on the cc_toolchain rule, override the transitive licenses
// with that one. This is necessary because cc_toolchain is used in the target configuration,
// but it is sort-of-kind-of a tool, but various parts of it are linked into the output...
// ...so we trust the judgment of the author of the cc_toolchain rule to figure out what
// licenses should be propagated to C++ targets.
License outputLicense = ruleContext.getRule().getToolOutputLicense(ruleContext.attributes());
if (outputLicense != null && outputLicense != License.NO_LICENSE) {
final NestedSet<TargetLicense> license =
NestedSetBuilder.create(
Order.STABLE_ORDER, new TargetLicense(ruleContext.getLabel(), outputLicense));
LicensesProvider licensesProvider =
new LicensesProvider() {
@Override
public NestedSet<TargetLicense> getTransitiveLicenses() {
return license;
}
};
builder.add(LicensesProvider.class, licensesProvider);
}
return builder.build();
}
/** Sets whether to enable compression of the output deploy archive. */
public DeployArchiveBuilder setCompression(Compression compress) {
this.compression = Preconditions.checkNotNull(compress);
return this;
}
/** Sets the artifact to create with the action. */
public DeployArchiveBuilder setOutputJar(Artifact outputJar) {
this.outputJar = Preconditions.checkNotNull(outputJar);
return this;
}
