Examples with EnvironmentWithGroup com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup used on opensource projects

Example 1 with EnvironmentWithGroup

use of com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup in project bazel by bazelbuild.

the class ConstraintSemantics method checkConstraints.

/**
   * Performs constraint checking on the given rule's dependencies and reports any errors. This
   * includes:
   *
   * <ul>
   *   <li>Static environment checking: if this rule supports environment E, all deps outside
   *     selects must also support E
   *   <li>Refined environment computation: this rule's refined environments are its static
   *     environments intersected with the refined environments of all dependencies (including
   *     chosen deps in selects)
   *   <li>Refined environment checking: no environment groups can be "emptied" due to refinement
   * </ul>
   *
   * @param ruleContext the rule to analyze
   * @param staticEnvironments the rule's supported environments, as defined by the return
   *     value of {@link #getSupportedEnvironments}. In particular, for any environment group that's
   *     not in this collection, the rule is assumed to support the defaults for that group.
   * @param refinedEnvironments a builder for populating this rule's refined environments
   * @param removedEnvironmentCulprits a builder for populating the core dependencies that trigger
   *     pruning away environments through refinement. If multiple dependencies qualify (e.g.
   *     two direct deps under the current rule), one is arbitrarily chosen.
   */
public static void checkConstraints(RuleContext ruleContext, EnvironmentCollection staticEnvironments, EnvironmentCollection.Builder refinedEnvironments, Map<Label, Target> removedEnvironmentCulprits) {
    Set<EnvironmentWithGroup> refinedEnvironmentsSoFar = new LinkedHashSet<>();
    // Start with the full set of static environments:
    refinedEnvironmentsSoFar.addAll(staticEnvironments.getGroupedEnvironments());
    Set<EnvironmentGroup> groupsWithEnvironmentsRemoved = new LinkedHashSet<>();
    // Maps the label results of getUnsupportedEnvironments() to EnvironmentWithGroups. We can't
    // have that method just return EnvironmentWithGroups because it also collects group defaults,
    // which we only have labels for.
    Map<Label, EnvironmentWithGroup> labelsToEnvironments = new HashMap<>();
    for (EnvironmentWithGroup envWithGroup : staticEnvironments.getGroupedEnvironments()) {
        labelsToEnvironments.put(envWithGroup.environment(), envWithGroup);
    }
    DepsToCheck depsToCheck = getConstraintCheckedDependencies(ruleContext);
    for (TransitiveInfoCollection dep : depsToCheck.allDeps()) {
        SupportedEnvironmentsProvider depEnvironments = dep.getProvider(SupportedEnvironmentsProvider.class);
        if (!depsToCheck.isSelectOnly(dep)) {
            // TODO(bazel-team): support static constraint checking for selects. A selectable constraint
            // is valid if the union of all deps in the select includes all of this rule's static
            // environments. Determining that requires following the select paths that don't get chosen,
            // which means we won't have ConfiguredTargets for those deps and need to find another
            // way to get their environments.
            Collection<Label> unsupportedEnvironments = getUnsupportedEnvironments(depEnvironments.getStaticEnvironments(), staticEnvironments);
            if (!unsupportedEnvironments.isEmpty()) {
                ruleContext.ruleError("dependency " + dep.getLabel() + " doesn't support expected environment" + (unsupportedEnvironments.size() == 1 ? "" : "s") + ": " + Joiner.on(", ").join(unsupportedEnvironments));
            }
        }
        // Refine this rule's environments by intersecting with the dep's refined environments:
        for (Label refinedEnvironmentToPrune : getUnsupportedEnvironments(depEnvironments.getRefinedEnvironments(), staticEnvironments)) {
            EnvironmentWithGroup envToPrune = labelsToEnvironments.get(refinedEnvironmentToPrune);
            if (envToPrune == null) {
                // set before trying to remove specific items.
                for (EnvironmentWithGroup defaultEnv : getDefaults(refinedEnvironmentToPrune, depEnvironments.getRefinedEnvironments())) {
                    refinedEnvironmentsSoFar.add(defaultEnv);
                    labelsToEnvironments.put(defaultEnv.environment(), defaultEnv);
                }
                envToPrune = Verify.verifyNotNull(labelsToEnvironments.get(refinedEnvironmentToPrune));
            }
            refinedEnvironmentsSoFar.remove(envToPrune);
            groupsWithEnvironmentsRemoved.add(envToPrune.group());
            removedEnvironmentCulprits.put(envToPrune.environment(), findOriginalRefiner(ruleContext, depEnvironments, envToPrune));
        }
    }
    checkRefinedEnvironmentConstraints(ruleContext, groupsWithEnvironmentsRemoved, refinedEnvironmentsSoFar, refinedEnvironments, removedEnvironmentCulprits);
}

Example 2 with EnvironmentWithGroup

use of com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup in project bazel by bazelbuild.

the class ConstraintSemantics method getUnsupportedEnvironments.

/**
   * Given a collection of environments and a collection of expected environments, returns the
   * missing environments that would cause constraint expectations to be violated. Includes
   * the effects of environment group defaults.
   */
public static Collection<Label> getUnsupportedEnvironments(EnvironmentCollection actualEnvironments, EnvironmentCollection expectedEnvironments) {
    Set<Label> missingEnvironments = new LinkedHashSet<>();
    Collection<Label> actualEnvironmentLabels = actualEnvironments.getEnvironments();
    // Check if each explicitly expected environment is satisfied.
    for (EnvironmentWithGroup expectedEnv : expectedEnvironments.getGroupedEnvironments()) {
        EnvironmentGroup group = expectedEnv.group();
        Label environment = expectedEnv.environment();
        boolean isSatisfied = false;
        if (actualEnvironments.getGroups().contains(group)) {
            // need to either find the environment itself or another one that transitively fulfills it.
            if (actualEnvironmentLabels.contains(environment) || intersect(actualEnvironmentLabels, group.getFulfillers(environment))) {
                isSatisfied = true;
            }
        } else {
            // either the expected environment or another environment that transitively fulfills it.
            if (group.isDefault(environment) || intersect(group.getFulfillers(environment), group.getDefaults())) {
                isSatisfied = true;
            }
        }
        if (!isSatisfied) {
            missingEnvironments.add(environment);
        }
    }
    // group (since in that case the same defaults apply), otherwise we have to check.
    for (EnvironmentGroup group : actualEnvironments.getGroups()) {
        if (!expectedEnvironments.getGroups().contains(group)) {
            for (Label expectedDefault : group.getDefaults()) {
                if (!actualEnvironmentLabels.contains(expectedDefault) && !intersect(actualEnvironmentLabels, group.getFulfillers(expectedDefault))) {
                    missingEnvironments.add(expectedDefault);
                }
            }
        }
    }
    return missingEnvironments;
}

Example 3 with EnvironmentWithGroup

use of com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup in project bazel by bazelbuild.

the class ConstraintSemantics method getDefaults.

/**
   * Finds the given environment in the given set and returns the default environments for its
   * group.
   */
private static Collection<EnvironmentWithGroup> getDefaults(Label env, EnvironmentCollection allEnvironments) {
    EnvironmentGroup group = null;
    for (EnvironmentGroup candidateGroup : allEnvironments.getGroups()) {
        if (candidateGroup.getDefaults().contains(env)) {
            group = candidateGroup;
            break;
        }
    }
    Verify.verifyNotNull(group);
    ImmutableSet.Builder<EnvironmentWithGroup> builder = ImmutableSet.builder();
    for (Label defaultEnv : group.getDefaults()) {
        builder.add(EnvironmentWithGroup.create(defaultEnv, group));
    }
    return builder.build();
}

Example 4 with EnvironmentWithGroup

use of com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup in project bazel by bazelbuild.

the class ConstraintSemantics method checkRefinedEnvironmentConstraints.

/**
   * Helper method for checkConstraints: performs refined environment constraint checking.
   *
   * <p>Refined environment expectations: no environment group should be emptied out due to
   * refining. This reflects the idea that some of the static declared environments get pruned
   * out by the build configuration, but <i>all</i> environments shouldn't be pruned out.
   *
   * <p>Violations of this expectation trigger rule analysis errors.
   */
private static void checkRefinedEnvironmentConstraints(RuleContext ruleContext, Set<EnvironmentGroup> groupsWithEnvironmentsRemoved, Set<EnvironmentWithGroup> refinedEnvironmentsSoFar, EnvironmentCollection.Builder refinedEnvironments, Map<Label, Target> removedEnvironmentCulprits) {
    Set<EnvironmentGroup> refinedGroups = new LinkedHashSet<>();
    for (EnvironmentWithGroup envWithGroup : refinedEnvironmentsSoFar) {
        refinedEnvironments.put(envWithGroup.group(), envWithGroup.environment());
        refinedGroups.add(envWithGroup.group());
    }
    Set<EnvironmentGroup> newlyEmptyGroups = groupsWithEnvironmentsRemoved.isEmpty() ? ImmutableSet.<EnvironmentGroup>of() : Sets.difference(groupsWithEnvironmentsRemoved, refinedGroups);
    if (!newlyEmptyGroups.isEmpty()) {
        ruleContext.ruleError(getOverRefinementError(newlyEmptyGroups, removedEnvironmentCulprits));
    }
}