diff --git a/site/en/docs/platforms.md b/site/en/docs/platforms.md
index 256db39d6e49d0..9284b34c939752 100644
--- a/site/en/docs/platforms.md
+++ b/site/en/docs/platforms.md
@@ -245,3 +245,8 @@ def format(target):
 
 $ bazel cquery //... --output=starlark --starlark:file=example.cquery
 ```
+
+### Known Issues
+
+Incompatible targets [ignore visibility
+restrictions](https://github.com/bazelbuild/bazel/issues/16044).
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/BUILD b/src/main/java/com/google/devtools/build/lib/analysis/BUILD
index 5f115fbcacb940..33dc8f06a97a2b 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/analysis/BUILD
@@ -2208,6 +2208,41 @@ java_library(
     ],
 )
 
+java_library(
+    name = "constraints/incompatible_target_checker",
+    srcs = ["constraints/IncompatibleTargetChecker.java"],
+    deps = [
+        ":analysis_cluster",
+        ":file_provider",
+        ":incompatible_platform_provider",
+        ":test/test_configuration",
+        ":transitive_info_provider_map_builder",
+        "//src/main/java/com/google/devtools/build/lib/actions:artifacts",
+        "//src/main/java/com/google/devtools/build/lib/analysis/platform",
+        "//src/main/java/com/google/devtools/build/lib/analysis/platform:utils",
+        "//src/main/java/com/google/devtools/build/lib/analysis:config/build_configuration",
+        "//src/main/java/com/google/devtools/build/lib/analysis:config/config_conditions",
+        "//src/main/java/com/google/devtools/build/lib/analysis:configured_target",
+        "//src/main/java/com/google/devtools/build/lib/analysis:configured_target_value",
+        "//src/main/java/com/google/devtools/build/lib/analysis:dependency",
+        "//src/main/java/com/google/devtools/build/lib/analysis:dependency_kind",
+        "//src/main/java/com/google/devtools/build/lib/analysis:target_and_configuration",
+        "//src/main/java/com/google/devtools/build/lib/analysis:transitive_info_collection",
+        "//src/main/java/com/google/devtools/build/lib/cmdline",
+        "//src/main/java/com/google/devtools/build/lib/collect/nestedset",
+        "//src/main/java/com/google/devtools/build/lib/packages",
+        "//src/main/java/com/google/devtools/build/lib/packages:configured_attribute_mapper",
+        "//src/main/java/com/google/devtools/build/lib/skyframe:configured_target_and_data",
+        "//src/main/java/com/google/devtools/build/lib/skyframe:configured_target_key",
+        "//src/main/java/com/google/devtools/build/lib/skyframe:rule_configured_target_value",
+        "//src/main/java/com/google/devtools/build/skyframe:skyframe-objects",
+        "//src/main/java/com/google/devtools/build/lib/util",
+        "//src/main/java/com/google/devtools/build/skyframe",
+        "//third_party:auto_value",
+        "//third_party:guava",
+    ],
+)
+
 # TODO(b/144899336): This should be analysis/starlark/BUILD
 java_library(
     name = "starlark/args",
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/BaseRuleClasses.java b/src/main/java/com/google/devtools/build/lib/analysis/BaseRuleClasses.java
index fbbaec9cc72358..bc14130e9cb3fb 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/BaseRuleClasses.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/BaseRuleClasses.java
@@ -403,8 +403,8 @@ public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env)
           .add(
               attr("distribs", DISTRIBUTIONS)
                   .nonconfigurable("Used in core loading phase logic with no access to configs"))
-          // Any rule that has provides its own meaning for the "target_compatible_with" attribute
-          // has to be excluded in `RuleContextConstraintSemantics.incompatibleConfiguredTarget()`.
+          // Any rule that provides its own meaning for the "target_compatible_with" attribute
+          // has to be excluded in `IncompatibleTargetChecker`.
           .add(
               attr(RuleClass.TARGET_COMPATIBLE_WITH_ATTR, LABEL_LIST)
                   .mandatoryProviders(ConstraintValueInfo.PROVIDER.id())
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredTargetFactory.java b/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredTargetFactory.java
index 390092c3623c04..977a65b29c9081 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredTargetFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredTargetFactory.java
@@ -38,7 +38,6 @@
 import com.google.devtools.build.lib.analysis.configuredtargets.OutputFileConfiguredTarget;
 import com.google.devtools.build.lib.analysis.configuredtargets.PackageGroupConfiguredTarget;
 import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget;
-import com.google.devtools.build.lib.analysis.constraints.RuleContextConstraintSemantics;
 import com.google.devtools.build.lib.analysis.starlark.StarlarkRuleConfiguredTargetUtil;
 import com.google.devtools.build.lib.analysis.test.AnalysisFailure;
 import com.google.devtools.build.lib.analysis.test.AnalysisFailureInfo;
@@ -325,12 +324,6 @@ private ConfiguredTarget createRule(
       return erroredConfiguredTarget(ruleContext);
     }
 
-    ConfiguredTarget incompatibleTarget =
-        RuleContextConstraintSemantics.incompatibleConfiguredTarget(ruleContext, prerequisiteMap);
-    if (incompatibleTarget != null) {
-      return incompatibleTarget;
-    }
-
     try {
       Class<?> missingFragmentClass = null;
       for (Class<? extends Fragment> fragmentClass :
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/RuleContext.java b/src/main/java/com/google/devtools/build/lib/analysis/RuleContext.java
index 98eab47cd14c8a..4ce591a69f5318 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/RuleContext.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/RuleContext.java
@@ -53,7 +53,6 @@
 import com.google.devtools.build.lib.analysis.config.FragmentCollection;
 import com.google.devtools.build.lib.analysis.config.transitions.ConfigurationTransition;
 import com.google.devtools.build.lib.analysis.config.transitions.NoTransition;
-import com.google.devtools.build.lib.analysis.constraints.RuleContextConstraintSemantics;
 import com.google.devtools.build.lib.analysis.platform.ConstraintValueInfo;
 import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
 import com.google.devtools.build.lib.analysis.starlark.StarlarkRuleContext;
@@ -2180,14 +2179,6 @@ private static boolean checkRuleDependencyMandatoryProviders(
 
     private void validateDirectPrerequisite(
         Attribute attribute, ConfiguredTargetAndData prerequisite) {
-      if (RuleContextConstraintSemantics.checkForIncompatibility(prerequisite.getConfiguredTarget())
-          .isIncompatible()) {
-        // If the prerequisite is incompatible (e.g. has an incompatible provider), we pretend that
-        // there is no further validation needed. Otherwise, it would be difficult to make the
-        // incompatible target satisfy things like required providers and file extensions.
-        return;
-      }
-
       validateDirectPrerequisiteType(prerequisite, attribute);
       validateDirectPrerequisiteFileTypes(prerequisite, attribute);
       if (attribute.performPrereqValidatorCheck()) {
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/RunfilesSupport.java b/src/main/java/com/google/devtools/build/lib/analysis/RunfilesSupport.java
index df040755f46277..ef668a7974a8be 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/RunfilesSupport.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/RunfilesSupport.java
@@ -448,22 +448,6 @@ public static RunfilesSupport withExecutable(
         computeActionEnvironment(ruleContext));
   }
 
-  /**
-   * Creates and returns a {@link RunfilesSupport} object for the given rule and executable. This
-   * version discards all arguments. Only use this for <a
-   * href="https://bazel.build/docs/platforms#skipping-incompatible-targets">Incompatible Target
-   * Skipping</a>.
-   */
-  public static RunfilesSupport withExecutableButNoArgs(
-      RuleContext ruleContext, Runfiles runfiles, Artifact executable) {
-    return RunfilesSupport.create(
-        ruleContext,
-        executable,
-        runfiles,
-        CommandLine.EMPTY,
-        computeActionEnvironment(ruleContext));
-  }
-
   private static CommandLine computeArgs(RuleContext ruleContext, CommandLine additionalArgs) {
     if (!ruleContext.getRule().isAttrDefined("args", Type.STRING_LIST)) {
       // Some non-_binary rules create RunfilesSupport instances; it is fine to not have an args
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
index eb6b28f72c3e6e..c52131d3a536a4 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
@@ -23,6 +23,7 @@
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.FileProvider;
 import com.google.devtools.build.lib.analysis.FilesToRunProvider;
+import com.google.devtools.build.lib.analysis.IncompatiblePlatformProvider;
 import com.google.devtools.build.lib.analysis.RuleContext;
 import com.google.devtools.build.lib.analysis.RunfilesProvider;
 import com.google.devtools.build.lib.analysis.TransitiveInfoProvider;
@@ -155,6 +156,28 @@ public RuleConfiguredTarget(
     }
   }
 
+  /** Use this constructor for creating incompatible ConfiguredTarget instances. */
+  public RuleConfiguredTarget(
+      Label label,
+      BuildConfigurationKey configurationKey,
+      NestedSet<PackageGroupContents> visibility,
+      TransitiveInfoProviderMap providers,
+      ImmutableMap<Label, ConfigMatchingProvider> configConditions,
+      String ruleClassString) {
+    this(
+        label,
+        configurationKey,
+        visibility,
+        providers,
+        configConditions,
+        ImmutableSet.<ConfiguredTargetKey>of(),
+        ruleClassString,
+        ImmutableList.<ActionAnalysisMetadata>of(),
+        ImmutableMap.<Label, Artifact>of());
+
+    Preconditions.checkState(providers.get(IncompatiblePlatformProvider.PROVIDER) != null, label);
+  }
+
   /** The configuration conditions that trigger this rule's configurable attributes. */
   @Override
   public ImmutableMap<Label, ConfigMatchingProvider> getConfigConditions() {
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/constraints/IncompatibleTargetChecker.java b/src/main/java/com/google/devtools/build/lib/analysis/constraints/IncompatibleTargetChecker.java
new file mode 100644
index 00000000000000..5f5a306575b8d3
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/analysis/constraints/IncompatibleTargetChecker.java
@@ -0,0 +1,272 @@
+// Copyright 2022 The Bazel Authors. All rights reserved.
+//
+// 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.google.devtools.build.lib.analysis.constraints;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.analysis.ConfiguredTarget;
+import com.google.devtools.build.lib.analysis.ConfiguredTargetValue;
+import com.google.devtools.build.lib.analysis.Dependency;
+import com.google.devtools.build.lib.analysis.DependencyKind;
+import com.google.devtools.build.lib.analysis.FileProvider;
+import com.google.devtools.build.lib.analysis.FilesToRunProvider;
+import com.google.devtools.build.lib.analysis.IncompatiblePlatformProvider;
+import com.google.devtools.build.lib.analysis.Runfiles;
+import com.google.devtools.build.lib.analysis.RunfilesProvider;
+import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
+import com.google.devtools.build.lib.analysis.TransitiveInfoProviderMapBuilder;
+import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue;
+import com.google.devtools.build.lib.analysis.config.ConfigConditions;
+import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget;
+import com.google.devtools.build.lib.analysis.platform.ConstraintValueInfo;
+import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
+import com.google.devtools.build.lib.analysis.platform.PlatformProviderUtils;
+import com.google.devtools.build.lib.analysis.test.TestActionBuilder;
+import com.google.devtools.build.lib.analysis.test.TestConfiguration;
+import com.google.devtools.build.lib.analysis.test.TestProvider;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+import com.google.devtools.build.lib.collect.nestedset.Order;
+import com.google.devtools.build.lib.packages.BuildType;
+import com.google.devtools.build.lib.packages.ConfiguredAttributeMapper;
+import com.google.devtools.build.lib.packages.Package;
+import com.google.devtools.build.lib.packages.PackageSpecification;
+import com.google.devtools.build.lib.packages.PackageSpecification.PackageGroupContents;
+import com.google.devtools.build.lib.packages.Rule;
+import com.google.devtools.build.lib.packages.Target;
+import com.google.devtools.build.lib.skyframe.ConfiguredTargetAndData;
+import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey;
+import com.google.devtools.build.lib.skyframe.RuleConfiguredTargetValue;
+import com.google.devtools.build.lib.util.OrderedSetMultimap;
+import com.google.devtools.build.skyframe.SkyFunction.Environment;
+import com.google.devtools.build.skyframe.SkyframeLookupResult;
+import java.util.List;
+import java.util.Optional;
+import javax.annotation.Nullable;
+
+/**
+ * Helpers for creating configured targets that are incompatible.
+ *
+ * <p>A target is considered incompatible if any of the following applies:
+ *
+ * <ol>
+ *   <li>The target's <code>target_compatible_with</code> attribute specifies a constraint that is
+ *       not present in the target platform. The target is said to be "directly incompatible".
+ *   <li>One or more of the target's dependencies is incompatible. The target is said to be
+ *       "indirectly incompatible."
+ * </ol>
+ *
+ * The intent of these helpers is that they get called as early in the analysis phase as possible.
+ * That's why there are two helpers instead of just one. The first helper determines direct
+ * incompatibility very early in the analysis phase. If a target is not directly incompatible, the
+ * dependencies need to be analysed and then we can check for indirect incompatibility. Doing these
+ * checks as early as possible allows us to skip analysing unused dependencies and ignore unused
+ * toolchains.
+ *
+ * <p>See https://bazel.build/docs/platforms#skipping-incompatible-targets for more information on
+ * incompatible target skipping.
+ */
+public class IncompatibleTargetChecker {
+  /**
+   * Creates an incompatible configured target if it is "directly incompatible".
+   *
+   * <p>In other words, this function checks if a target is incompatible because of its
+   * "target_compatible_with" attribute.
+   *
+   * <p>This function returns a nullable {@code Optional} of a {@link RuleConfiguredTargetValue}.
+   * This provides three states of return values:
+   *
+   * <ul>
+   *   <li>{@code null}: A skyframe restart is required.
+   *   <li>{@code Optional.empty()}: The target is not directly incompatible. Analysis can continue.
+   *   <li>{@code !Optional.empty()}: The target is directly incompatible. Analysis should not
+   *       continue.
+   * </ul>
+   */
+  @Nullable
+  public static Optional<RuleConfiguredTargetValue> createDirectlyIncompatibleTarget(
+      TargetAndConfiguration targetAndConfiguration,
+      ConfigConditions configConditions,
+      Environment env,
+      @Nullable PlatformInfo platformInfo,
+      NestedSetBuilder<Package> transitivePackagesForPackageRootResolution)
+      throws InterruptedException {
+    Target target = targetAndConfiguration.getTarget();
+    Rule rule = target.getAssociatedRule();
+
+    if (rule == null || rule.getRuleClass().equals("toolchain") || platformInfo == null) {
+      return Optional.empty();
+    }
+
+    // Retrieve the label list for the target_compatible_with attribute.
+    BuildConfigurationValue configuration = targetAndConfiguration.getConfiguration();
+    ConfiguredAttributeMapper attrs =
+        ConfiguredAttributeMapper.of(rule, configConditions.asProviders(), configuration);
+    if (!attrs.has("target_compatible_with", BuildType.LABEL_LIST)) {
+      return Optional.empty();
+    }
+
+    // Resolve the constraint labels.
+    List<Label> labels = attrs.get("target_compatible_with", BuildType.LABEL_LIST);
+    ImmutableList<ConfiguredTargetKey> constraintKeys =
+        labels.stream()
+            .map(
+                label ->
+                    Dependency.builder()
+                        .setLabel(label)
+                        .setConfiguration(configuration)
+                        .build()
+                        .getConfiguredTargetKey())
+            .collect(toImmutableList());
+    SkyframeLookupResult constraintValues = env.getValuesAndExceptions(constraintKeys);
+    if (env.valuesMissing()) {
+      return null;
+    }
+
+    // Find the constraints that don't satisfy the target platform.
+    ImmutableList<ConstraintValueInfo> invalidConstraintValues =
+        constraintKeys.stream()
+            .map(key -> (ConfiguredTargetValue) constraintValues.get(key))
+            .map(ctv -> PlatformProviderUtils.constraintValue(ctv.getConfiguredTarget()))
+            .filter(cv -> cv != null && !platformInfo.constraints().hasConstraintValue(cv))
+            .collect(toImmutableList());
+    if (invalidConstraintValues.isEmpty()) {
+      return Optional.empty();
+    }
+
+    return Optional.of(
+        createIncompatibleRuleConfiguredTarget(
+            target,
+            configuration,
+            configConditions,
+            IncompatiblePlatformProvider.incompatibleDueToConstraints(
+                platformInfo.label(), invalidConstraintValues),
+            rule.getRuleClass(),
+            transitivePackagesForPackageRootResolution));
+  }
+
+  /**
+   * Creates an incompatible target if it is "indirectly incompatible".
+   *
+   * <p>In other words, this function checks if a target is incompatible because of one of its
+   * dependencies. If a dependency is incompatible, then this target is also incompatible.
+   *
+   * <p>This function returns an {@code Optional} of a {@link RuleConfiguredTargetValue}. This
+   * provides two states of return values:
+   *
+   * <ul>
+   *   <li>{@code Optional.empty()}: The target is not indirectly incompatible. Analysis can
+   *       continue.
+   *   <li>{@code !Optional.empty()}: The target is indirectly incompatible. Analysis should not
+   *       continue.
+   * </ul>
+   */
+  public static Optional<RuleConfiguredTargetValue> createIndirectlyIncompatibleTarget(
+      TargetAndConfiguration targetAndConfiguration,
+      OrderedSetMultimap<DependencyKind, ConfiguredTargetAndData> depValueMap,
+      ConfigConditions configConditions,
+      @Nullable PlatformInfo platformInfo,
+      NestedSetBuilder<Package> transitivePackagesForPackageRootResolution) {
+    Target target = targetAndConfiguration.getTarget();
+    Rule rule = target.getAssociatedRule();
+
+    if (rule == null || rule.getRuleClass().equals("toolchain")) {
+      return Optional.empty();
+    }
+
+    // Find all the incompatible dependencies.
+    ImmutableList<ConfiguredTarget> incompatibleDeps =
+        depValueMap.values().stream()
+            .map(ConfiguredTargetAndData::getConfiguredTarget)
+            .filter(
+                dep -> RuleContextConstraintSemantics.checkForIncompatibility(dep).isIncompatible())
+            .collect(toImmutableList());
+    if (incompatibleDeps.isEmpty()) {
+      return Optional.empty();
+    }
+
+    BuildConfigurationValue configuration = targetAndConfiguration.getConfiguration();
+    Label platformLabel = platformInfo != null ? platformInfo.label() : null;
+    return Optional.of(
+        createIncompatibleRuleConfiguredTarget(
+            target,
+            configuration,
+            configConditions,
+            IncompatiblePlatformProvider.incompatibleDueToTargets(platformLabel, incompatibleDeps),
+            rule.getRuleClass(),
+            transitivePackagesForPackageRootResolution));
+  }
+
+  /** Creates an incompatible target. */
+  private static RuleConfiguredTargetValue createIncompatibleRuleConfiguredTarget(
+      Target target,
+      BuildConfigurationValue configuration,
+      ConfigConditions configConditions,
+      IncompatiblePlatformProvider incompatiblePlatformProvider,
+      String ruleClassString,
+      NestedSetBuilder<Package> transitivePackagesForPackageRootResolution) {
+    // Create dummy instances of the necessary data for a configured target. None of this data will
+    // actually be used because actions associated with incompatible targets must not be evaluated.
+    NestedSet<Artifact> filesToBuild = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
+    FileProvider fileProvider = new FileProvider(filesToBuild);
+    FilesToRunProvider filesToRunProvider = new FilesToRunProvider(filesToBuild, null, null);
+
+    TransitiveInfoProviderMapBuilder providerBuilder =
+        new TransitiveInfoProviderMapBuilder()
+            .put(incompatiblePlatformProvider)
+            .add(RunfilesProvider.simple(Runfiles.EMPTY))
+            .add(fileProvider)
+            .add(filesToRunProvider);
+    if (configuration.hasFragment(TestConfiguration.class)) {
+      // Create a dummy TestProvider instance so that other parts of the code base stay happy. Even
+      // though this test will never execute, some code still expects the provider.
+      TestProvider.TestParams testParams = TestActionBuilder.createEmptyTestParams();
+      providerBuilder.put(TestProvider.class, new TestProvider(testParams));
+    }
+
+    RuleConfiguredTarget configuredTarget =
+        new RuleConfiguredTarget(
+            target.getLabel(),
+            configuration.getKey(),
+            convertVisibility(),
+            providerBuilder.build(),
+            configConditions.asProviders(),
+            ruleClassString);
+    return new RuleConfiguredTargetValue(
+        configuredTarget,
+        transitivePackagesForPackageRootResolution == null
+            ? null
+            : transitivePackagesForPackageRootResolution.build());
+  }
+
+  /**
+   * Generates visibility for an incompatible target.
+   *
+   * <p>The intent is for this function is to match ConfiguredTargetFactory.convertVisibility().
+   * Since visibility is currently validated after incompatibility is evaluated, however, it doesn't
+   * matter what visibility we set here. To keep it simple, we pretend that all incompatible targets
+   * are public.
+   *
+   * <p>TODO(#16044): Set up properly validated visibility here.
+   */
+  private static NestedSet<PackageGroupContents> convertVisibility() {
+    return NestedSetBuilder.create(
+        Order.STABLE_ORDER,
+        PackageGroupContents.create(ImmutableList.of(PackageSpecification.everything())));
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/constraints/RuleContextConstraintSemantics.java b/src/main/java/com/google/devtools/build/lib/analysis/constraints/RuleContextConstraintSemantics.java
index ea888e9b6f4b62..d04b3cc2098adc 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/constraints/RuleContextConstraintSemantics.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/constraints/RuleContextConstraintSemantics.java
@@ -14,39 +14,24 @@
 
 package com.google.devtools.build.lib.analysis.constraints;
 
-import static com.google.common.collect.ImmutableList.toImmutableList;
 
 import com.google.auto.value.AutoValue;
 import com.google.common.base.Joiner;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
-import com.google.devtools.build.lib.actions.Artifact;
-import com.google.devtools.build.lib.actions.FailAction;
-import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
-import com.google.devtools.build.lib.analysis.DependencyKind;
 import com.google.devtools.build.lib.analysis.IncompatiblePlatformProvider;
 import com.google.devtools.build.lib.analysis.LabelAndLocation;
-import com.google.devtools.build.lib.analysis.RuleConfiguredTargetBuilder;
 import com.google.devtools.build.lib.analysis.RuleContext;
-import com.google.devtools.build.lib.analysis.Runfiles;
-import com.google.devtools.build.lib.analysis.RunfilesProvider;
-import com.google.devtools.build.lib.analysis.RunfilesSupport;
 import com.google.devtools.build.lib.analysis.TransitiveInfoCollection;
 import com.google.devtools.build.lib.analysis.configuredtargets.OutputFileConfiguredTarget;
 import com.google.devtools.build.lib.analysis.constraints.EnvironmentCollection.EnvironmentWithGroup;
 import com.google.devtools.build.lib.analysis.constraints.SupportedEnvironmentsProvider.RemovedEnvironmentCulprit;
-import com.google.devtools.build.lib.analysis.platform.ConstraintValueInfo;
-import com.google.devtools.build.lib.analysis.platform.PlatformProviderUtils;
-import com.google.devtools.build.lib.analysis.test.AnalysisTestResultInfo;
 import com.google.devtools.build.lib.cmdline.Label;
-import com.google.devtools.build.lib.collect.nestedset.NestedSet;
-import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
 import com.google.devtools.build.lib.packages.Attribute;
 import com.google.devtools.build.lib.packages.AttributeMap;
 import com.google.devtools.build.lib.packages.BuildType;
@@ -58,9 +43,6 @@
 import com.google.devtools.build.lib.packages.Type;
 import com.google.devtools.build.lib.packages.Type.LabelClass;
 import com.google.devtools.build.lib.packages.Type.LabelVisitor;
-import com.google.devtools.build.lib.server.FailureDetails.FailAction.Code;
-import com.google.devtools.build.lib.skyframe.ConfiguredTargetAndData;
-import com.google.devtools.build.lib.util.OrderedSetMultimap;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
@@ -882,159 +864,4 @@ public static IncompatibleCheckResult checkForIncompatibility(ConfiguredTarget t
     return IncompatibleCheckResult.create(
         target.get(IncompatiblePlatformProvider.PROVIDER) != null, target);
   }
-
-  /**
-   * Creates an incompatible {@link ConfiguredTarget} if the corresponding rule is incompatible.
-   *
-   * <p>Returns null if the target is not incompatible.
-   *
-   * <p>"Incompatible" here means either:
-   *
-   * <ol>
-   *   <li>the corresponding <code>target_compatible_with</code> list contains a constraint that the
-   *       current platform doesn't satisfy, or
-   *   <li>a transitive dependency is incompatible.
-   * </ol>
-   *
-   * @param ruleContext analysis context for the rule
-   * @param prerequisiteMap the dependencies of the rule
-   * @throws ActionConflictException if the underlying {@link RuleConfiguredTargetBuilder}
-   *     encounters a problem when assembling a dummy action for the incompatible {@link
-   *     ConfiguredTarget}.
-   */
-  @Nullable
-  public static ConfiguredTarget incompatibleConfiguredTarget(
-      RuleContext ruleContext,
-      OrderedSetMultimap<DependencyKind, ConfiguredTargetAndData> prerequisiteMap)
-      throws ActionConflictException, InterruptedException {
-    // The target (ruleContext) is incompatible if explicitly specified to be. Any rule that
-    // provides its own meaning for the "target_compatible_with" attribute has to be excluded here.
-    // For example, the "toolchain" rule uses "target_compatible_with" for bazel's toolchain
-    // resolution.
-    if (!ruleContext.getRule().getRuleClass().equals("toolchain")
-        && ruleContext.attributes().has("target_compatible_with")) {
-      ImmutableList<ConstraintValueInfo> invalidConstraintValues =
-          PlatformProviderUtils.constraintValues(
-                  ruleContext.getPrerequisites("target_compatible_with"))
-              .stream()
-              .filter(cv -> !ruleContext.targetPlatformHasConstraint(cv))
-              .collect(toImmutableList());
-
-      if (!invalidConstraintValues.isEmpty()) {
-        return createIncompatibleConfiguredTarget(ruleContext, null, invalidConstraintValues);
-      }
-    }
-
-    // This is incompatible if one of the dependencies is as well.
-    ImmutableList<ConfiguredTarget> incompatibleDependencies =
-        prerequisiteMap.values().stream()
-            .map(value -> checkForIncompatibility(value.getConfiguredTarget()))
-            .filter(IncompatibleCheckResult::isIncompatible)
-            .map(IncompatibleCheckResult::underlyingTarget)
-            .collect(toImmutableList());
-    if (!incompatibleDependencies.isEmpty()) {
-      return createIncompatibleConfiguredTarget(ruleContext, incompatibleDependencies, null);
-    }
-
-    return null;
-  }
-
-  /**
-   * A helper function for incompatibleConfiguredTarget() to actually create the incompatible {@link
-   * ConfiguredTarget}.
-   *
-   * @param ruleContext analysis context for the rule
-   * @param targetsResponsibleForIncompatibility the targets that are responsible this target's
-   *     incompatibility. If null, that means that target is responsible for its own
-   *     incompatibility. I.e. it has constraints in target_compatible_with that were not satisfied
-   *     on the target platform. This must be null if violatedConstraints is set. This must be set
-   *     if violatedConstraints is null.
-   * @param violatedConstraints the constraints that the target platform doesn't satisfy. This must
-   *     be null if targetRsesponsibleForIncompatibility is set.
-   * @throws ActionConflictException if the underlying {@link RuleConfiguredTargetBuilder}
-   *     encounters a problem when assembling a dummy action for the incompatible {@link
-   *     ConfiguredTarget}.
-   */
-  private static ConfiguredTarget createIncompatibleConfiguredTarget(
-      RuleContext ruleContext,
-      @Nullable ImmutableList<ConfiguredTarget> targetsResponsibleForIncompatibility,
-      @Nullable ImmutableList<ConstraintValueInfo> violatedConstraints)
-      throws ActionConflictException, InterruptedException {
-    // Create a dummy ConfiguredTarget that has the IncompatiblePlatformProvider set.
-    ImmutableList<Artifact> outputArtifacts = ruleContext.getOutputArtifacts();
-
-    if (ruleContext.isTestTarget() && outputArtifacts.isEmpty()) {
-      // Test targets require RunfilesSupport to be added to the RuleConfiguredTargetBuilder
-      // which needs an "executable".  Create one here if none exist already.
-      //
-      // It would be ideal if we could avoid this. Currently the problem is that some rules like
-      // sh_test only declare an output artifact in the corresponding ConfiguredTarget factory
-      // function (see ShBinary.java). Since this code path here replaces the factory function rules
-      // like sh_test never get a chance to declare an output artifact.
-      //
-      // On top of that, the rest of the code base makes the assumption that test targets provide an
-      // instance RunfilesSupport. This can be seen in the TestProvider, the TestActionBuilder, and
-      // the RuleConfiguredTargetBuilder classes. There might be a way to break this assumption, but
-      // it's currently too heavily baked in to work around it more nicely than this.
-      //
-      // Theoretically, this hack shouldn't be an issue because the corresponding actions will never
-      // get executed. They cannot be queried either.
-      outputArtifacts = ImmutableList.of(ruleContext.createOutputArtifact());
-    }
-
-    NestedSet<Artifact> filesToBuild =
-        NestedSetBuilder.<Artifact>stableOrder().addAll(outputArtifacts).build();
-
-    Runfiles.Builder runfilesBuilder =
-        new Runfiles.Builder(
-            ruleContext.getWorkspaceName(),
-            ruleContext.getConfiguration().legacyExternalRunfiles());
-    Runfiles runfiles =
-        runfilesBuilder
-            .addTransitiveArtifacts(filesToBuild)
-            .addRunfiles(ruleContext, RunfilesProvider.DEFAULT_RUNFILES)
-            .build();
-
-    RuleConfiguredTargetBuilder builder = new RuleConfiguredTargetBuilder(ruleContext);
-    builder.setFilesToBuild(filesToBuild);
-
-    if (targetsResponsibleForIncompatibility != null) {
-      builder.addNativeDeclaredProvider(
-          IncompatiblePlatformProvider.incompatibleDueToTargets(
-              ruleContext.targetPlatform(), targetsResponsibleForIncompatibility));
-    } else if (violatedConstraints != null) {
-      builder.addNativeDeclaredProvider(
-          IncompatiblePlatformProvider.incompatibleDueToConstraints(
-              ruleContext.targetPlatform(), violatedConstraints));
-    } else {
-      throw new IllegalArgumentException(
-          "Both violatedConstraints and targetsResponsibleForIncompatibility are null");
-    }
-
-    // If this is an analysis test, RuleConfiguredTargetBuilder performs some additional sanity
-    // checks. Satisfy them with an appropriate provider.
-    if (ruleContext.getRule().isAnalysisTest()) {
-      builder.addNativeDeclaredProvider(
-          new AnalysisTestResultInfo(
-              /*success=*/ false,
-              "This test is incompatible and should not have been run. Please file a bug"
-                  + " upstream."));
-    }
-
-    builder.add(RunfilesProvider.class, RunfilesProvider.simple(runfiles));
-    if (!outputArtifacts.isEmpty()) {
-      Artifact executable = outputArtifacts.get(0);
-      RunfilesSupport runfilesSupport =
-          RunfilesSupport.withExecutableButNoArgs(ruleContext, runfiles, executable);
-      builder.setRunfilesSupport(runfilesSupport, executable);
-
-      ruleContext.registerAction(
-          new FailAction(
-              ruleContext.getActionOwner(),
-              outputArtifacts,
-              "Can't build this. This target is incompatible. Please file a bug upstream.",
-              Code.CANT_BUILD_INCOMPATIBLE_TARGET));
-    }
-    return builder.build();
-  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/constraints/TopLevelConstraintSemantics.java b/src/main/java/com/google/devtools/build/lib/analysis/constraints/TopLevelConstraintSemantics.java
index 5a381ebb5d9ec9..7c4d15ec8b9281 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/constraints/TopLevelConstraintSemantics.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/constraints/TopLevelConstraintSemantics.java
@@ -325,9 +325,12 @@ private static String reportOnIncompatibility(ConfiguredTarget target) {
 
     message += "s [";
 
+    // Print out a sorted list to make the output reproducible.
     boolean first = true;
     for (ConstraintValueInfo constraintValueInfo :
-        provider.constraintsResponsibleForIncompatibility()) {
+        ImmutableList.sortedCopyOf(
+            (ConstraintValueInfo a, ConstraintValueInfo b) -> b.label().compareTo(a.label()),
+            provider.constraintsResponsibleForIncompatibility())) {
       if (first) {
         first = false;
       } else {
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/test/TestActionBuilder.java b/src/main/java/com/google/devtools/build/lib/analysis/test/TestActionBuilder.java
index efc890ba89db80..69539f7b5857fb 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/test/TestActionBuilder.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/test/TestActionBuilder.java
@@ -106,6 +106,26 @@ public TestActionBuilder(RuleContext ruleContext) {
     this.additionalTools = new ImmutableList.Builder<>();
   }
 
+  /**
+   * Creates test actions for a test that will never be executed.
+   *
+   * <p>This is only really useful for things like creating incompatible test actions.
+   */
+  public static TestParams createEmptyTestParams() {
+    NestedSet<Artifact> filesToBuild = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
+    FilesToRunProvider filesToRunProvider = new FilesToRunProvider(filesToBuild, null, null);
+    return new TestProvider.TestParams(
+        0,
+        0,
+        false,
+        TestTimeout.ETERNAL,
+        "invalid",
+        ImmutableList.<Artifact.DerivedArtifact>of(),
+        ImmutableList.<Artifact>of(),
+        filesToRunProvider,
+        ImmutableList.<ActionInput>of());
+  }
+
   /**
    * Creates the test actions and artifacts using the previously set parameters.
    *
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/BUILD b/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
index cae50895fa30c1..658a70b5cf848f 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
@@ -255,6 +255,7 @@ java_library(
         "//src/main/java/com/google/devtools/build/lib/analysis:configured_object_value",
         "//src/main/java/com/google/devtools/build/lib/analysis:configured_target",
         "//src/main/java/com/google/devtools/build/lib/analysis:configured_target_value",
+        "//src/main/java/com/google/devtools/build/lib/analysis:constraints/incompatible_target_checker",
         "//src/main/java/com/google/devtools/build/lib/analysis:dependency",
         "//src/main/java/com/google/devtools/build/lib/analysis:dependency_key",
         "//src/main/java/com/google/devtools/build/lib/analysis:dependency_kind",
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/ConfiguredTargetFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/ConfiguredTargetFunction.java
index ddcc8d29fbc390..d2c84731ae68a8 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/ConfiguredTargetFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/ConfiguredTargetFunction.java
@@ -55,6 +55,7 @@
 import com.google.devtools.build.lib.analysis.config.ToolchainTypeRequirement;
 import com.google.devtools.build.lib.analysis.config.transitions.PatchTransition;
 import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget;
+import com.google.devtools.build.lib.analysis.constraints.IncompatibleTargetChecker;
 import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
 import com.google.devtools.build.lib.bugreport.BugReport;
 import com.google.devtools.build.lib.causes.AnalysisFailedCause;
@@ -98,6 +99,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
@@ -301,6 +303,8 @@ public SkyValue compute(SkyKey key, Environment env)
       }
       unloadedToolchainContexts = result.toolchainCollection;
       execGroupCollectionBuilder = result.execGroupCollectionBuilder;
+      PlatformInfo platformInfo =
+          unloadedToolchainContexts != null ? unloadedToolchainContexts.getTargetPlatform() : null;
 
       // Get the configuration targets that trigger this rule's configurable attributes.
       ConfigConditions configConditions =
@@ -308,9 +312,7 @@ public SkyValue compute(SkyKey key, Environment env)
               env,
               targetAndConfiguration,
               state.transitivePackagesForPackageRootResolution,
-              unloadedToolchainContexts == null
-                  ? null
-                  : unloadedToolchainContexts.getTargetPlatform(),
+              platformInfo,
               state.transitiveRootCauses);
       if (env.valuesMissing()) {
         return null;
@@ -335,6 +337,20 @@ public SkyValue compute(SkyKey key, Environment env)
                 getPrioritizedDetailedExitCode(causes)));
       }
 
+      Optional<RuleConfiguredTargetValue> incompatibleTarget =
+          IncompatibleTargetChecker.createDirectlyIncompatibleTarget(
+              targetAndConfiguration,
+              configConditions,
+              env,
+              platformInfo,
+              state.transitivePackagesForPackageRootResolution);
+      if (incompatibleTarget == null) {
+        return null;
+      }
+      if (incompatibleTarget.isPresent()) {
+        return incompatibleTarget.get();
+      }
+
       // Calculate the dependencies of this target.
       OrderedSetMultimap<DependencyKind, ConfiguredTargetAndData> depValueMap =
           computeDependencies(
@@ -367,6 +383,17 @@ public SkyValue compute(SkyKey key, Environment env)
       }
       Preconditions.checkNotNull(depValueMap);
 
+      incompatibleTarget =
+          IncompatibleTargetChecker.createIndirectlyIncompatibleTarget(
+              targetAndConfiguration,
+              depValueMap,
+              configConditions,
+              platformInfo,
+              state.transitivePackagesForPackageRootResolution);
+      if (incompatibleTarget.isPresent()) {
+        return incompatibleTarget.get();
+      }
+
       // Load the requested toolchains into the ToolchainContext, now that we have dependencies.
       ToolchainCollection<ResolvedToolchainContext> toolchainContexts = null;
       if (unloadedToolchainContexts != null) {
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/RuleConfiguredTargetValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/RuleConfiguredTargetValue.java
index a1ca50cffc23c6..4eba615a10e3ec 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/RuleConfiguredTargetValue.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/RuleConfiguredTargetValue.java
@@ -49,7 +49,7 @@ public final class RuleConfiguredTargetValue
     this(configuredTarget, /*transitivePackagesForPackageRootResolution=*/ null);
   }
 
-  RuleConfiguredTargetValue(
+  public RuleConfiguredTargetValue(
       RuleConfiguredTarget configuredTarget,
       @Nullable NestedSet<Package> transitivePackagesForPackageRootResolution) {
     this.configuredTarget = Preconditions.checkNotNull(configuredTarget);
diff --git a/src/test/shell/integration/target_compatible_with_test.sh b/src/test/shell/integration/target_compatible_with_test.sh
index c9e83de68c36e9..042fe678ac8992 100755
--- a/src/test/shell/integration/target_compatible_with_test.sh
+++ b/src/test/shell/integration/target_compatible_with_test.sh
@@ -182,6 +182,14 @@ sh_binary(
         ":foo3",
     ],
 )
+
+# Use this to let us change select() statements from the command line.
+config_setting(
+  name = "setting1",
+  define_values = {
+    "foo": "1",
+  },
+)
 EOF
 }
 
@@ -192,6 +200,77 @@ function tear_down() {
   bazel shutdown
 }
 
+function set_up_custom_toolchain() {
+  mkdir -p target_skipping/custom_tools/
+  cat > target_skipping/custom_tools/BUILD <<EOF
+load(":toolchain.bzl", "custom_toolchain")
+
+toolchain_type(name = "toolchain_type")
+
+custom_toolchain(
+    name = "toolchain",
+    compiler_path = "customc",
+)
+
+toolchain(
+    name = "custom_foo3_toolchain",
+    exec_compatible_with = [
+        "//target_skipping:foo3",
+    ],
+    target_compatible_with = [
+        "//target_skipping:foo3",
+    ],
+    toolchain = ":toolchain",
+    toolchain_type = ":toolchain_type",
+)
+EOF
+
+  cat > target_skipping/custom_tools/toolchain.bzl <<EOF
+def _custom_binary_impl(ctx):
+    info = ctx.toolchains["//target_skipping/custom_tools:toolchain_type"].custom_info
+    out = ctx.actions.declare_file(ctx.label.name)
+    ctx.actions.write(out, "%s %s" % (info.compiler_path, ctx.file.src.short_path))
+
+custom_binary = rule(
+    implementation = _custom_binary_impl,
+    attrs = {
+        "src": attr.label(allow_single_file=True),
+    },
+    toolchains = ["//target_skipping/custom_tools:toolchain_type"],
+)
+
+CustomInfo = provider(
+    fields = {
+        "compiler_path": "The path to the compiler binary",
+    },
+)
+
+def _custom_toolchain_impl(ctx):
+    return [platform_common.ToolchainInfo(
+        custom_info = CustomInfo(
+            compiler_path = ctx.attr.compiler_path,
+        ),
+    )]
+
+custom_toolchain = rule(
+    implementation = _custom_toolchain_impl,
+    attrs = {
+        "compiler_path": attr.string(),
+    },
+)
+
+def _compiler_flag_impl(ctx):
+    toolchain = ctx.toolchains["//target_skipping/custom_tools:toolchain_type"].custom_info
+    return [config_common.FeatureFlagInfo(value = toolchain.compiler_path)]
+
+compiler_flag = rule(
+    implementation = _compiler_flag_impl,
+    toolchains = ["//target_skipping/custom_tools:toolchain_type"],
+    incompatible_use_toolchain_transition = True,
+)
+EOF
+}
+
 # Validates that we get a good error message when passing a config_setting into
 # the target_compatible_with attribute. This is a regression test for
 # https://github.com/bazelbuild/bazel/issues/13250.
@@ -800,6 +879,148 @@ EOF
   expect_log '^//target_skipping:pass_on_everything_but_foo1_and_foo2  *  PASSED in'
 }
 
+function test_incompatible_with_aliased_constraint() {
+  cat >> target_skipping/BUILD <<EOF
+alias(
+    name = "also_foo3",
+    actual = ":foo3",
+)
+
+alias(
+    name = "again_foo3",
+    actual = ":foo3",
+)
+
+cc_library(
+    name = "some_library",
+    target_compatible_with = select({
+        ":also_foo3": [":again_foo3"],
+        "//conditions:default": [":not_compatible"],
+    }),
+)
+EOF
+
+  cd target_skipping || fail "couldn't cd into workspace"
+
+  bazel build \
+    --show_result=10 \
+    --host_platform=@//target_skipping:foo3_platform \
+    --platforms=@//target_skipping:foo3_platform \
+    //target_skipping/... &> "${TEST_log}" \
+    || fail "Bazel build failed unexpectedly."
+  expect_log 'Target //target_skipping:some_library up-to-date'
+}
+
+function test_incompatible_with_aliased_target() {
+  cat >> target_skipping/BUILD <<EOF
+alias(
+    name = "also_some_foo3_target",
+    actual = ":some_foo3_target",
+)
+EOF
+
+  # Try with :foo1. This should fail.
+  bazel test \
+    --show_result=10 \
+    --host_platform=@//target_skipping:foo1_bar1_platform \
+    --platforms=@//target_skipping:foo1_bar1_platform \
+    //target_skipping:also_some_foo3_target  &> "${TEST_log}" \
+    && fail "Bazel passed unexpectedly."
+  expect_log 'ERROR: Target //target_skipping:also_some_foo3_target is incompatible and cannot be built, but was explicitly requested'
+  expect_log 'FAILED: Build did NOT complete successfully'
+}
+
+# Validate that an incompatible target with a toolchain not available for the
+# current platform will not cause an analysis error. This is a regression test
+# for https://github.com/bazelbuild/bazel/issues/12897.
+function test_incompatible_with_missing_toolchain() {
+  set_up_custom_toolchain
+
+  cat >> target_skipping/BUILD <<EOF
+load(
+    "//target_skipping/custom_tools:toolchain.bzl",
+    "compiler_flag",
+    "custom_binary",
+)
+
+objc_library(
+    name = "objc",
+    target_compatible_with = select({
+        ":setting1": ["//target_skipping:foo1"],
+        "//conditions:default": ["//target_skipping:foo2"],
+    }),
+)
+
+custom_binary(
+    name = "custom1",
+    src = "custom.txt",
+    target_compatible_with = ["//target_skipping:foo1"],
+)
+
+compiler_flag(name = "compiler_flag")
+
+config_setting(
+    name = "using_custom_toolchain",
+    flag_values = {
+        ":compiler_flag": "customc",
+    },
+)
+
+custom_binary(
+    name = "custom2",
+    src = "custom.txt",
+    target_compatible_with = select({
+        ":using_custom_toolchain": [":not_compatible"],
+        "//conditions:default": [],
+    }),
+)
+EOF
+
+  cat > target_skipping/custom.txt <<EOF
+This is a custom dummy file.
+EOF
+
+  cd target_skipping || fail "couldn't cd into workspace"
+
+  bazel build --define=foo=1 \
+    --show_result=10 \
+    --extra_toolchains=//target_skipping/custom_tools:custom_foo3_toolchain \
+    --host_platform=@//target_skipping:foo3_platform \
+    --platforms=@//target_skipping:foo3_platform \
+    //target_skipping/... &> "${TEST_log}" \
+    || fail "Bazel build failed unexpectedly."
+  expect_log 'Target //target_skipping:objc was skipped'
+  expect_log 'Target //target_skipping:custom1 was skipped'
+  expect_log 'Target //target_skipping:custom2 was skipped'
+}
+
+# Validates that if a target is "directly incompatible" then its dependencies
+# are not evaluated. I.e. there should be no need to guard the dependencies
+# with a select() statement.
+function test_invalid_deps_are_ignored_when_incompatible() {
+  cat >> target_skipping/BUILD <<EOF
+cc_binary(
+    name = "incompatible_tool",
+    deps = [
+        "//nonexistent_dep",
+    ],
+    target_compatible_with = [
+        ":foo1",
+    ],
+)
+EOF
+
+  cd target_skipping || fail "couldn't cd into workspace"
+
+  bazel build \
+    --show_result=10 \
+    --host_platform=@//target_skipping:foo3_platform \
+    --platforms=@//target_skipping:foo3_platform \
+    //target_skipping/... &> "${TEST_log}" \
+    || fail "Bazel build failed unexpectedly."
+  expect_log 'Target //target_skipping:incompatible_tool was skipped'
+}
+
 # Validates that a tool compatible with the host platform, but incompatible
 # with the target platform can still be used as a host tool.
 function test_host_tool() {