private void visitRule( Rule rule, AspectDefinition aspect, AspectParameters aspectParameters, ListMultimap<Attribute, LabelAndConfiguration> labelMap, ListMultimap<Attribute, Dependency> outgoingEdges) { Preconditions.checkNotNull(labelMap); for (Map.Entry<Attribute, Collection<LabelAndConfiguration>> entry : labelMap.asMap().entrySet()) { Attribute attribute = entry.getKey(); for (LabelAndConfiguration dep : entry.getValue()) { Label label = dep.getLabel(); BuildConfiguration config = dep.getConfiguration(); Target toTarget; try { toTarget = getTarget(label); } catch (NoSuchThingException e) { throw new IllegalStateException( "not found: " + label + " from " + rule + " in " + attribute.getName()); } if (toTarget == null) { continue; } BuildConfiguration.TransitionApplier transitionApplier = config.getTransitionApplier(); if (config.useDynamicConfigurations() && config.isHostConfiguration() && !BuildConfiguration.usesNullConfiguration(toTarget)) { // This condition is needed because resolveLateBoundAttributes may switch config to // the host configuration, which is the only case DependencyResolver applies a // configuration transition outside of this method. We need to reflect that // transition in the results of this method, but config.evaluateTransition is hard-set // to return a NONE transition when the input is a host config. Since the outside // caller originally passed the *original* value of config (before the possible // switch), it can mistakenly interpret the result as a NONE transition from the // original value of config. This condition fixes that. Another fix would be to have // config.evaluateTransition return a HOST transition when the input config is a host, // but since this blemish is specific to DependencyResolver it seems best to keep the // fix here. // TODO(bazel-team): eliminate this special case by passing transitionApplier to // resolveLateBoundAttributes, so that method uses the same interface for transitions. transitionApplier.applyTransition(Attribute.ConfigurationTransition.HOST); } else { config.evaluateTransition(rule, attribute, toTarget, transitionApplier); } for (Dependency dependency : transitionApplier.getDependencies( label, requiredAspects(aspect, aspectParameters, attribute, toTarget, rule))) { outgoingEdges.put(entry.getKey(), dependency); } } } }
private void resolveExplicitAttributes( Rule rule, final BuildConfiguration configuration, AttributeMap attributes, final ImmutableSortedKeyListMultimap.Builder<Attribute, LabelAndConfiguration> builder) { attributes.visitLabels( new AttributeMap.AcceptsLabelAttribute() { @Override public void acceptLabelAttribute(Label label, Attribute attribute) { String attributeName = attribute.getName(); if (attributeName.equals("abi_deps")) { // abi_deps is handled specially: we visit only the branch that // needs to be taken based on the configuration. return; } if (attribute.getType() == BuildType.NODEP_LABEL) { return; } if (attribute.isImplicit() || attribute.isLateBound()) { return; } builder.put(attribute, LabelAndConfiguration.of(label, configuration)); } }); // TODO(bazel-team): Remove this in favor of the new configurable attributes. if (attributes.getAttributeDefinition("abi_deps") != null) { Attribute depsAttribute = attributes.getAttributeDefinition("deps"); MakeVariableExpander.Context context = new ConfigurationMakeVariableContext(rule.getPackage(), configuration); String abi = null; try { abi = MakeVariableExpander.expand(attributes.get("abi", Type.STRING), context); } catch (MakeVariableExpander.ExpansionException e) { // Ignore this. It will be handled during the analysis phase. } if (abi != null) { for (Map.Entry<String, List<Label>> entry : attributes.get("abi_deps", BuildType.LABEL_LIST_DICT).entrySet()) { try { if (Pattern.matches(entry.getKey(), abi)) { for (Label label : entry.getValue()) { builder.put(depsAttribute, LabelAndConfiguration.of(label, configuration)); } } } catch (PatternSyntaxException e) { // Ignore this. It will be handled during the analysis phase. } } } } }
private void resolveImplicitAttributes( Rule rule, BuildConfiguration configuration, AttributeMap attributeMap, Iterable<Attribute> attributes, ImmutableSortedKeyListMultimap.Builder<Attribute, LabelAndConfiguration> builder) { // Since the attributes that come from aspects do not appear in attributeMap, we have to get // their values from somewhere else. This incidentally means that aspects attributes are not // configurable. It would be nice if that wasn't the case, but we'd have to revamp how // attribute mapping works, which is a large chunk of work. ImmutableSet<String> mappedAttributes = ImmutableSet.copyOf(attributeMap.getAttributeNames()); for (Attribute attribute : attributes) { if (!attribute.isImplicit() || !attribute.getCondition().apply(attributeMap)) { continue; } if (attribute.getType() == BuildType.LABEL) { Label label = mappedAttributes.contains(attribute.getName()) ? attributeMap.get(attribute.getName(), BuildType.LABEL) : BuildType.LABEL.cast(attribute.getDefaultValue(rule)); if (label != null) { builder.put(attribute, LabelAndConfiguration.of(label, configuration)); } } else if (attribute.getType() == BuildType.LABEL_LIST) { List<Label> labelList = mappedAttributes.contains(attribute.getName()) ? attributeMap.get(attribute.getName(), BuildType.LABEL_LIST) : BuildType.LABEL_LIST.cast(attribute.getDefaultValue(rule)); for (Label label : labelList) { builder.put(attribute, LabelAndConfiguration.of(label, configuration)); } } } }
/** * Adds new dependencies to the given rule under the given attribute name * * @param result the builder for the attribute --> dependency labels map * @param rule the rule being evaluated * @param attrName the name of the attribute to add dependency labels to * @param labels the dependencies to add * @param configuration the configuration to apply to those dependencies */ private void addExplicitDeps( ImmutableSortedKeyListMultimap.Builder<Attribute, LabelAndConfiguration> result, Rule rule, String attrName, Iterable<Label> labels, BuildConfiguration configuration) { if (!rule.isAttrDefined(attrName, BuildType.LABEL_LIST) && !rule.isAttrDefined(attrName, BuildType.NODEP_LABEL_LIST)) { return; } Attribute attribute = rule.getRuleClassObject().getAttributeByName(attrName); for (Label label : labels) { // The configuration must be the configuration after the first transition step (applying // split configurations). The proper configuration (null) for package groups will be set // later. result.put(attribute, LabelAndConfiguration.of(label, configuration)); } }
private void resolveLateBoundAttributes( Rule rule, BuildConfiguration configuration, BuildConfiguration hostConfiguration, AttributeMap attributeMap, Iterable<Attribute> attributes, ImmutableSortedKeyListMultimap.Builder<Attribute, LabelAndConfiguration> builder) throws EvalException, InterruptedException { for (Attribute attribute : attributes) { if (!attribute.isLateBound() || !attribute.getCondition().apply(attributeMap)) { continue; } List<BuildConfiguration> actualConfigurations = ImmutableList.of(configuration); if (attribute.getConfigurationTransition() instanceof SplitTransition<?>) { Preconditions.checkState(attribute.getConfigurator() == null); // TODO(bazel-team): This ends up applying the split transition twice, both here and in the // visitRule method below - this is not currently a problem, because the configuration graph // never contains nested split transitions, so the second application is idempotent. actualConfigurations = configuration.getSplitConfigurations( (SplitTransition<?>) attribute.getConfigurationTransition()); } for (BuildConfiguration actualConfig : actualConfigurations) { @SuppressWarnings("unchecked") LateBoundDefault<BuildConfiguration> lateBoundDefault = (LateBoundDefault<BuildConfiguration>) attribute.getLateBoundDefault(); if (lateBoundDefault.useHostConfiguration()) { actualConfig = hostConfiguration; } // TODO(bazel-team): This might be too expensive - can we cache this somehow? if (!lateBoundDefault.getRequiredConfigurationFragments().isEmpty()) { if (!actualConfig.hasAllFragments(lateBoundDefault.getRequiredConfigurationFragments())) { continue; } } // TODO(bazel-team): We should check if the implementation tries to access an undeclared // fragment. Object actualValue = lateBoundDefault.getDefault(rule, actualConfig); if (EvalUtils.isNullOrNone(actualValue)) { continue; } try { if (attribute.getType() == BuildType.LABEL) { Label label = BuildType.LABEL.cast(actualValue); builder.put(attribute, LabelAndConfiguration.of(label, actualConfig)); } else if (attribute.getType() == BuildType.LABEL_LIST) { for (Label label : BuildType.LABEL_LIST.cast(actualValue)) { builder.put(attribute, LabelAndConfiguration.of(label, actualConfig)); } } else { throw new IllegalStateException( String.format( "Late bound attribute '%s' is not a label or a label list", attribute.getName())); } } catch (ClassCastException e) { throw new EvalException( rule.getLocation(), String.format( "When computing the default value of %s, expected '%s', got '%s'", attribute.getName(), attribute.getType(), EvalUtils.getDataTypeName(actualValue, true))); } } } }