diff --git a/src/main/java/com/google/devtools/build/lib/analysis/ToolchainResolver.java b/src/main/java/com/google/devtools/build/lib/analysis/ToolchainResolver.java
deleted file mode 100644
index 4a92d5b..0000000
--- a/src/main/java/com/google/devtools/build/lib/analysis/ToolchainResolver.java
+++ /dev/null
@@ -1,507 +0,0 @@
-// Copyright 2018 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;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static java.util.stream.Collectors.joining;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Table;
-import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
-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.ToolchainTypeInfo;
-import com.google.devtools.build.lib.cmdline.Label;
-import com.google.devtools.build.lib.events.Event;
-import com.google.devtools.build.lib.skyframe.BuildConfigurationValue;
-import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey;
-import com.google.devtools.build.lib.skyframe.ConstraintValueLookupUtil;
-import com.google.devtools.build.lib.skyframe.ConstraintValueLookupUtil.InvalidConstraintValueException;
-import com.google.devtools.build.lib.skyframe.PlatformLookupUtil;
-import com.google.devtools.build.lib.skyframe.PlatformLookupUtil.InvalidPlatformException;
-import com.google.devtools.build.lib.skyframe.RegisteredExecutionPlatformsValue;
-import com.google.devtools.build.lib.skyframe.RegisteredToolchainsFunction.InvalidToolchainLabelException;
-import com.google.devtools.build.lib.skyframe.SingleToolchainResolutionFunction;
-import com.google.devtools.build.lib.skyframe.SingleToolchainResolutionFunction.NoToolchainFoundException;
-import com.google.devtools.build.lib.skyframe.SingleToolchainResolutionValue;
-import com.google.devtools.build.lib.skyframe.ToolchainException;
-import com.google.devtools.build.lib.skyframe.UnloadedToolchainContext;
-import com.google.devtools.build.skyframe.SkyFunction.Environment;
-import com.google.devtools.build.skyframe.SkyKey;
-import com.google.devtools.build.skyframe.ValueOrException2;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nullable;
-
-/**
- * Performs the toolchain resolution process to determine the correct toolchain target dependencies
- * for a target being configured, based on the required toolchain types, target platform, and
- * available execution platforms.
- */
-public class ToolchainResolver {
-  // Required data.
-  private final Environment environment;
-  private final BuildConfigurationValue.Key configurationKey;
-
-  // Optional data.
-  private ImmutableSet<Label> requiredToolchainTypeLabels = ImmutableSet.of();
-  private ImmutableSet<Label> execConstraintLabels = ImmutableSet.of();
-  private boolean shouldSanityCheckConfiguration = false;
-
-  // Determined during execution.
-  private boolean debug = false;
-
-  /**
-   * Creates a new {@link ToolchainResolver} to help find the required toolchains for a configured
-   * target.
-   *
-   * @param env the environment to use to request dependent Skyframe nodes
-   * @param configurationKey The build configuration to use for dependent targets
-   */
-  public ToolchainResolver(Environment env, BuildConfigurationValue.Key configurationKey) {
-    this.environment = checkNotNull(env);
-    this.configurationKey = checkNotNull(configurationKey);
-  }
-
-  /**
-   * Sets the labels of the required toolchain types that this resolver needs to find toolchains
-   * for.
-   */
-  public ToolchainResolver setRequiredToolchainTypes(Set<Label> requiredToolchainTypeLabels) {
-    this.requiredToolchainTypeLabels = ImmutableSet.copyOf(requiredToolchainTypeLabels);
-    return this;
-  }
-
-  /**
-   * Sets extra constraints on the execution platform. Targets can use this to ensure that the
-   * execution platform has some desired characteristics, such as having enough memory to run tests.
-   */
-  public ToolchainResolver setExecConstraintLabels(Set<Label> execConstraintLabels) {
-    this.execConstraintLabels = ImmutableSet.copyOf(execConstraintLabels);
-    return this;
-  }
-
-  /**
-   * Sets whether the experimental retroactive trimming mode is in use. This determines whether
-   * sanity checks regarding the fragments in use for the configurations of platforms and toolchains
-   * are used - specifically, whether platforms use only the PlatformConfiguration, and toolchains
-   * do not use any configuration at all.
-   */
-  public ToolchainResolver setShouldSanityCheckConfiguration(boolean useSanityChecks) {
-    this.shouldSanityCheckConfiguration = useSanityChecks;
-    return this;
-  }
-
-  /**
-   * Determines the specific toolchains that are required, given the requested toolchain types,
-   * target platform, and configuration.
-   *
-   * <p>In order to resolve toolchains, first the {@link ToolchainResolver} must be created, and
-   * then an {@link UnloadedToolchainContext} generated. The {@link UnloadedToolchainContext} will
-   * report the specific toolchain targets to depend on, and those can be found using the typical
-   * dependency machinery. Once dependencies, including toolchains, have been loaded, the {@link
-   * ResolvedToolchainContext#load} method can be called to generate the final {@link
-   * ResolvedToolchainContext} to be used by the target.
-   *
-   * <p>This makes several SkyFrame calls, particularly to {@link
-   * com.google.devtools.build.lib.skyframe.ConfiguredTargetFunction} (to load platforms and
-   * toolchains), to {@link
-   * com.google.devtools.build.lib.skyframe.RegisteredExecutionPlatformsFunction}, and to {@link
-   * SingleToolchainResolutionFunction}. This method returns {@code null} to signal a SkyFrame
-   * restart is needed to resolve dependencies.
-   */
-  @Nullable
-  public UnloadedToolchainContext resolve() throws InterruptedException, ToolchainException {
-
-    try {
-      UnloadedToolchainContext.Builder unloadedToolchainContext =
-          UnloadedToolchainContext.builder();
-
-      // Determine the configuration being used.
-      BuildConfigurationValue value =
-          (BuildConfigurationValue) environment.getValue(configurationKey);
-      if (value == null) {
-        throw new ValueMissingException();
-      }
-      BuildConfiguration configuration = value.getConfiguration();
-      PlatformConfiguration platformConfiguration =
-          configuration.getFragment(PlatformConfiguration.class);
-      if (platformConfiguration == null) {
-        throw new ValueMissingException();
-      }
-
-      // Check if debug output should be generated.
-      this.debug = configuration.getOptions().get(PlatformOptions.class).toolchainResolutionDebug;
-
-      // Create keys for all platforms that will be used, and validate them early.
-      PlatformKeys platformKeys = loadPlatformKeys(configuration, platformConfiguration);
-      if (environment.valuesMissing()) {
-        return null;
-      }
-
-      // Determine the actual toolchain implementations to use.
-      determineToolchainImplementations(unloadedToolchainContext, platformKeys);
-
-      return unloadedToolchainContext.build();
-    } catch (ValueMissingException e) {
-      return null;
-    }
-  }
-
-  @AutoValue
-  abstract static class PlatformKeys {
-    abstract ConfiguredTargetKey hostPlatformKey();
-
-    abstract ConfiguredTargetKey targetPlatformKey();
-
-    abstract ImmutableList<ConfiguredTargetKey> executionPlatformKeys();
-
-    static PlatformKeys create(
-        ConfiguredTargetKey hostPlatformKey,
-        ConfiguredTargetKey targetPlatformKey,
-        List<ConfiguredTargetKey> executionPlatformKeys) {
-      return new AutoValue_ToolchainResolver_PlatformKeys(
-          hostPlatformKey, targetPlatformKey, ImmutableList.copyOf(executionPlatformKeys));
-    }
-  }
-
-  private PlatformKeys loadPlatformKeys(
-      BuildConfiguration configuration, PlatformConfiguration platformConfiguration)
-      throws InterruptedException, InvalidPlatformException, ValueMissingException,
-          InvalidConstraintValueException {
-    // Determine the target and host platform keys.
-    Label hostPlatformLabel = platformConfiguration.getHostPlatform();
-    Label targetPlatformLabel = platformConfiguration.getTargetPlatform();
-
-    ConfiguredTargetKey hostPlatformKey = ConfiguredTargetKey.of(hostPlatformLabel, configuration);
-    ConfiguredTargetKey targetPlatformKey =
-        ConfiguredTargetKey.of(targetPlatformLabel, configuration);
-
-    // Load the host and target platforms early, to check for errors.
-    PlatformLookupUtil.getPlatformInfo(
-        ImmutableList.of(hostPlatformKey, targetPlatformKey),
-        environment,
-        shouldSanityCheckConfiguration);
-    if (environment.valuesMissing()) {
-      throw new ValueMissingException();
-    }
-
-    ImmutableList<ConfiguredTargetKey> executionPlatformKeys =
-        loadExecutionPlatformKeys(configuration, hostPlatformKey);
-
-    return PlatformKeys.create(hostPlatformKey, targetPlatformKey, executionPlatformKeys);
-  }
-
-  private ImmutableList<ConfiguredTargetKey> loadExecutionPlatformKeys(
-      BuildConfiguration configuration, ConfiguredTargetKey defaultPlatformKey)
-      throws InvalidPlatformException, InterruptedException, InvalidConstraintValueException,
-          ValueMissingException {
-    RegisteredExecutionPlatformsValue registeredExecutionPlatforms =
-        (RegisteredExecutionPlatformsValue)
-            environment.getValueOrThrow(
-                RegisteredExecutionPlatformsValue.key(configurationKey),
-                InvalidPlatformException.class);
-    if (registeredExecutionPlatforms == null) {
-      throw new ValueMissingException();
-    }
-
-    ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys =
-        new ImmutableList.Builder<ConfiguredTargetKey>()
-            .addAll(registeredExecutionPlatforms.registeredExecutionPlatformKeys())
-            .add(defaultPlatformKey)
-            .build();
-
-    // Filter out execution platforms that don't satisfy the extra constraints.
-    ImmutableList<ConfiguredTargetKey> execConstraintKeys =
-        execConstraintLabels.stream()
-            .map(label -> ConfiguredTargetKey.of(label, configuration))
-            .collect(toImmutableList());
-
-    return filterAvailablePlatforms(availableExecutionPlatformKeys, execConstraintKeys);
-  }
-
-  /** Returns only the platform keys that match the given constraints. */
-  private ImmutableList<ConfiguredTargetKey> filterAvailablePlatforms(
-      ImmutableList<ConfiguredTargetKey> platformKeys,
-      ImmutableList<ConfiguredTargetKey> constraintKeys)
-      throws InterruptedException, InvalidPlatformException, InvalidConstraintValueException,
-          ValueMissingException {
-
-    // Short circuit if not needed.
-    if (constraintKeys.isEmpty()) {
-      return platformKeys;
-    }
-
-    // At this point the host and target platforms have been loaded, but not necessarily the chosen
-    // execution platform (it might be the same as the host platform, and might not).
-    //
-    // It's not worth trying to optimize away this call, since in the optimizable case (the exec
-    // platform is the host platform), Skyframe will return the correct results immediately without
-    // need of a restart.
-    Map<ConfiguredTargetKey, PlatformInfo> platformInfoMap =
-        PlatformLookupUtil.getPlatformInfo(
-            platformKeys, environment, shouldSanityCheckConfiguration);
-    if (platformInfoMap == null) {
-      throw new ValueMissingException();
-    }
-    List<ConstraintValueInfo> constraints =
-        ConstraintValueLookupUtil.getConstraintValueInfo(constraintKeys, environment);
-    if (constraints == null) {
-      throw new ValueMissingException();
-    }
-
-    return platformKeys.stream()
-        .filter(key -> filterPlatform(platformInfoMap.get(key), constraints))
-        .collect(toImmutableList());
-  }
-
-  /** Returns {@code true} if the given platform has all of the constraints. */
-  private boolean filterPlatform(PlatformInfo platformInfo, List<ConstraintValueInfo> constraints) {
-    ImmutableList<ConstraintValueInfo> missingConstraints =
-        platformInfo.constraints().findMissing(constraints);
-    if (debug) {
-      for (ConstraintValueInfo constraint : missingConstraints) {
-        // The value for this setting is not present in the platform, or doesn't match the expected
-        // value.
-        environment
-            .getListener()
-            .handle(
-                Event.info(
-                    String.format(
-                        "ToolchainResolver: Removed execution platform %s from"
-                            + " available execution platforms, it is missing constraint %s",
-                        platformInfo.label(), constraint.label())));
-        }
-    }
-
-    return missingConstraints.isEmpty();
-  }
-
-  private void determineToolchainImplementations(
-      UnloadedToolchainContext.Builder unloadedToolchainContext, PlatformKeys platformKeys)
-      throws InterruptedException, ToolchainException, ValueMissingException {
-
-    // Find the toolchains for the required toolchain types.
-    List<SingleToolchainResolutionValue.Key> registeredToolchainKeys = new ArrayList<>();
-    for (Label toolchainTypeLabel : requiredToolchainTypeLabels) {
-      registeredToolchainKeys.add(
-          SingleToolchainResolutionValue.key(
-              configurationKey,
-              toolchainTypeLabel,
-              platformKeys.targetPlatformKey(),
-              platformKeys.executionPlatformKeys()));
-    }
-
-    Map<SkyKey, ValueOrException2<NoToolchainFoundException, InvalidToolchainLabelException>>
-        results =
-            environment.getValuesOrThrow(
-                registeredToolchainKeys,
-                NoToolchainFoundException.class,
-                InvalidToolchainLabelException.class);
-    boolean valuesMissing = false;
-
-    // Determine the potential set of toolchains.
-    Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains =
-        HashBasedTable.create();
-    ImmutableSet.Builder<ToolchainTypeInfo> requiredToolchainTypesBuilder = ImmutableSet.builder();
-    List<Label> missingToolchains = new ArrayList<>();
-    for (Map.Entry<
-            SkyKey, ValueOrException2<NoToolchainFoundException, InvalidToolchainLabelException>>
-        entry : results.entrySet()) {
-      try {
-        ValueOrException2<NoToolchainFoundException, InvalidToolchainLabelException>
-            valueOrException = entry.getValue();
-        SingleToolchainResolutionValue singleToolchainResolutionValue =
-            (SingleToolchainResolutionValue) valueOrException.get();
-        if (singleToolchainResolutionValue == null) {
-          valuesMissing = true;
-          continue;
-        }
-
-        ToolchainTypeInfo requiredToolchainType = singleToolchainResolutionValue.toolchainType();
-        requiredToolchainTypesBuilder.add(requiredToolchainType);
-        resolvedToolchains.putAll(
-            findPlatformsAndLabels(requiredToolchainType, singleToolchainResolutionValue));
-      } catch (NoToolchainFoundException e) {
-        // Save the missing type and continue looping to check for more.
-        missingToolchains.add(e.missingToolchainTypeLabel());
-      }
-    }
-
-    if (!missingToolchains.isEmpty()) {
-      throw new UnresolvedToolchainsException(missingToolchains);
-    }
-
-    if (valuesMissing) {
-      throw new ValueMissingException();
-    }
-
-    ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes = requiredToolchainTypesBuilder.build();
-
-    // Find and return the first execution platform which has all required toolchains.
-    Optional<ConfiguredTargetKey> selectedExecutionPlatformKey;
-    if (requiredToolchainTypeLabels.isEmpty()
-        && platformKeys.executionPlatformKeys().contains(platformKeys.hostPlatformKey())) {
-      // Fall back to the legacy behavior: use the host platform if it's available, otherwise the
-      // first execution platform.
-      selectedExecutionPlatformKey = Optional.of(platformKeys.hostPlatformKey());
-    } else {
-      // If there are no toolchains, this will return the first execution platform.
-      selectedExecutionPlatformKey =
-          findExecutionPlatformForToolchains(
-              requiredToolchainTypes, platformKeys.executionPlatformKeys(), resolvedToolchains);
-    }
-
-    if (!selectedExecutionPlatformKey.isPresent()) {
-      throw new NoMatchingPlatformException(
-          requiredToolchainTypeLabels,
-          platformKeys.executionPlatformKeys(),
-          platformKeys.targetPlatformKey());
-    }
-
-    Map<ConfiguredTargetKey, PlatformInfo> platforms =
-        PlatformLookupUtil.getPlatformInfo(
-            ImmutableList.of(selectedExecutionPlatformKey.get(), platformKeys.targetPlatformKey()),
-            environment,
-            shouldSanityCheckConfiguration);
-    if (platforms == null) {
-      throw new ValueMissingException();
-    }
-
-    unloadedToolchainContext.setRequiredToolchainTypes(requiredToolchainTypes);
-    unloadedToolchainContext.setExecutionPlatform(
-        platforms.get(selectedExecutionPlatformKey.get()));
-    unloadedToolchainContext.setTargetPlatform(platforms.get(platformKeys.targetPlatformKey()));
-
-    Map<ToolchainTypeInfo, Label> toolchains =
-        resolvedToolchains.row(selectedExecutionPlatformKey.get());
-    unloadedToolchainContext.setToolchainTypeToResolved(ImmutableBiMap.copyOf(toolchains));
-  }
-
-  /**
-   * Adds all of toolchain labels from{@code toolchainResolutionValue} to {@code
-   * resolvedToolchains}.
-   */
-  private static Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> findPlatformsAndLabels(
-      ToolchainTypeInfo requiredToolchainType,
-      SingleToolchainResolutionValue singleToolchainResolutionValue) {
-
-    Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains =
-        HashBasedTable.create();
-    for (Map.Entry<ConfiguredTargetKey, Label> entry :
-        singleToolchainResolutionValue.availableToolchainLabels().entrySet()) {
-      resolvedToolchains.put(entry.getKey(), requiredToolchainType, entry.getValue());
-    }
-    return resolvedToolchains;
-  }
-
-  /**
-   * Finds the first platform from {@code availableExecutionPlatformKeys} that is present in {@code
-   * resolvedToolchains} and has all required toolchain types.
-   */
-  private Optional<ConfiguredTargetKey> findExecutionPlatformForToolchains(
-      ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes,
-      ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys,
-      Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains) {
-    for (ConfiguredTargetKey executionPlatformKey : availableExecutionPlatformKeys) {
-      Map<ToolchainTypeInfo, Label> toolchains = resolvedToolchains.row(executionPlatformKey);
-
-      if (!toolchains.keySet().containsAll(requiredToolchainTypes)) {
-        // Not all toolchains are present, keep going
-        continue;
-      }
-
-      if (debug) {
-        String selectedToolchains =
-            toolchains.entrySet().stream()
-                .map(
-                    e ->
-                        String.format(
-                            "type %s -> toolchain %s", e.getKey().typeLabel(), e.getValue()))
-                .collect(joining(", "));
-        environment
-            .getListener()
-            .handle(
-                Event.info(
-                    String.format(
-                        "ToolchainResolver: Selected execution platform %s, %s",
-                        executionPlatformKey.getLabel(), selectedToolchains)));
-      }
-      return Optional.of(executionPlatformKey);
-    }
-
-    return Optional.empty();
-  }
-
-  private static final class ValueMissingException extends Exception {
-    private ValueMissingException() {
-      super();
-    }
-  }
-
-  /** Exception used when no execution platform can be found. */
-  static final class NoMatchingPlatformException extends ToolchainException {
-    NoMatchingPlatformException(
-        Set<Label> requiredToolchainTypeLabels,
-        ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys,
-        ConfiguredTargetKey targetPlatformKey) {
-      super(
-          formatError(
-              requiredToolchainTypeLabels, availableExecutionPlatformKeys, targetPlatformKey));
-    }
-
-    private static String formatError(
-        Set<Label> requiredToolchainTypeLabels,
-        ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys,
-        ConfiguredTargetKey targetPlatformKey) {
-      if (requiredToolchainTypeLabels.isEmpty()) {
-        return String.format(
-            "Unable to find an execution platform for target platform %s"
-                + " from available execution platforms [%s]",
-            targetPlatformKey.getLabel(),
-            availableExecutionPlatformKeys.stream()
-                .map(key -> key.getLabel().toString())
-                .collect(Collectors.joining(", ")));
-      }
-      return String.format(
-          "Unable to find an execution platform for toolchains [%s] and target platform %s"
-              + " from available execution platforms [%s]",
-          requiredToolchainTypeLabels.stream().map(Label::toString).collect(joining(", ")),
-          targetPlatformKey.getLabel(),
-          availableExecutionPlatformKeys.stream()
-              .map(key -> key.getLabel().toString())
-              .collect(Collectors.joining(", ")));
-    }
-  }
-
-  /** Exception used when a toolchain type is required but no matching toolchain is found. */
-  static final class UnresolvedToolchainsException extends ToolchainException {
-    UnresolvedToolchainsException(List<Label> missingToolchainTypes) {
-      super(
-          String.format(
-              "no matching toolchains found for types %s",
-              missingToolchainTypes.stream().map(Label::toString).collect(joining(", "))));
-    }
-  }
-}
diff --git a/src/main/java/com/google/devtools/build/lib/query2/PostAnalysisQueryEnvironment.java b/src/main/java/com/google/devtools/build/lib/query2/PostAnalysisQueryEnvironment.java
index dff58a5..edefd40 100644
--- a/src/main/java/com/google/devtools/build/lib/query2/PostAnalysisQueryEnvironment.java
+++ b/src/main/java/com/google/devtools/build/lib/query2/PostAnalysisQueryEnvironment.java
@@ -13,6 +13,7 @@
 // limitations under the License.
 package com.google.devtools.build.lib.query2;
 
+
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -368,17 +369,26 @@
 
   protected abstract RuleConfiguredTarget getRuleConfiguredTarget(T target);
 
+  protected Collection<T> targetifyValues(Iterable<SkyKey> dependencies)
+      throws InterruptedException {
+    Collection<T> values = new ArrayList<>();
+    for (SkyKey key : dependencies) {
+      if (key.functionName().equals(SkyFunctions.CONFIGURED_TARGET)) {
+        values.add(getValueFromKey(key));
+      } else if (key.functionName().equals(SkyFunctions.TOOLCHAIN_RESOLUTION)) {
+        // Also fetch these dependencies.
+        Collection<T> toolchainDeps = targetifyValues(graph.getDirectDeps(key));
+        values.addAll(toolchainDeps);
+      }
+    }
+    return values;
+  }
+
   protected Map<SkyKey, Collection<T>> targetifyValues(
       Map<SkyKey, ? extends Iterable<SkyKey>> input) throws InterruptedException {
     Map<SkyKey, Collection<T>> result = new HashMap<>();
     for (Map.Entry<SkyKey, ? extends Iterable<SkyKey>> entry : input.entrySet()) {
-      Collection<T> value = new ArrayList<>();
-      for (SkyKey key : entry.getValue()) {
-        if (key.functionName().equals(SkyFunctions.CONFIGURED_TARGET)) {
-          value.add(getValueFromKey(key));
-        }
-      }
-      result.put(entry.getKey(), value);
+      result.put(entry.getKey(), targetifyValues(entry.getValue()));
     }
     return result;
   }
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
index 743c7d2..d278350 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
@@ -31,7 +31,6 @@
 import com.google.devtools.build.lib.analysis.DependencyResolver.InconsistentAspectOrderException;
 import com.google.devtools.build.lib.analysis.ResolvedToolchainContext;
 import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
-import com.google.devtools.build.lib.analysis.ToolchainResolver;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.analysis.config.BuildOptions;
 import com.google.devtools.build.lib.analysis.config.ConfigMatchingProvider;
@@ -413,9 +412,15 @@
         try {
           ImmutableSet<Label> requiredToolchains = aspect.getDefinition().getRequiredToolchains();
           unloadedToolchainContext =
-              new ToolchainResolver(env, BuildConfigurationValue.key(configuration))
-                  .setRequiredToolchainTypes(requiredToolchains)
-                  .resolve();
+              (UnloadedToolchainContext)
+                  env.getValueOrThrow(
+                      UnloadedToolchainContext.key()
+                          .configurationKey(BuildConfigurationValue.key(configuration))
+                          .requiredToolchainTypeLabels(requiredToolchains)
+                          .shouldSanityCheckConfiguration(
+                              configuration.trimConfigurationsRetroactively())
+                          .build(),
+                      ToolchainException.class);
         } catch (ToolchainException e) {
           // TODO(katre): better error handling
           throw new AspectCreationException(
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 a266129..1e36cb7 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
@@ -37,7 +37,6 @@
 import com.google.devtools.build.lib.analysis.EmptyConfiguredTarget;
 import com.google.devtools.build.lib.analysis.ResolvedToolchainContext;
 import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
-import com.google.devtools.build.lib.analysis.ToolchainResolver;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.analysis.config.BuildOptions;
 import com.google.devtools.build.lib.analysis.config.ConfigMatchingProvider;
@@ -309,12 +308,16 @@
           // Collect local (target, rule) constraints for filtering out execution platforms.
           ImmutableSet<Label> execConstraintLabels = getExecutionPlatformConstraints(rule);
           unloadedToolchainContext =
-              new ToolchainResolver(env, configuredTargetKey.getConfigurationKey())
-                  .setRequiredToolchainTypes(requiredToolchains)
-                  .setExecConstraintLabels(execConstraintLabels)
-                  .setShouldSanityCheckConfiguration(
-                      configuration.trimConfigurationsRetroactively())
-                  .resolve();
+              (UnloadedToolchainContext)
+                  env.getValueOrThrow(
+                      UnloadedToolchainContext.key()
+                          .configurationKey(configuredTargetKey.getConfigurationKey())
+                          .requiredToolchainTypeLabels(requiredToolchains)
+                          .execConstraintLabels(execConstraintLabels)
+                          .shouldSanityCheckConfiguration(
+                              configuration.trimConfigurationsRetroactively())
+                          .build(),
+                      ToolchainException.class);
           if (env.valuesMissing()) {
             return null;
           }
@@ -426,10 +429,8 @@
               e.getCauses()));
     } catch (ToolchainException e) {
       // We need to throw a ConfiguredValueCreationException, so either find one or make one.
-      ConfiguredValueCreationException cvce;
-      if (e.getCause() instanceof ConfiguredValueCreationException) {
-        cvce = (ConfiguredValueCreationException) e.getCause();
-      } else {
+      ConfiguredValueCreationException cvce = e.asConfiguredValueCreationException();
+      if (cvce == null) {
         cvce =
             new ConfiguredValueCreationException(e.getMessage(), target.getLabel(), configuration);
       }
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
index da00c9f..76cdaf3 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
@@ -138,7 +138,7 @@
       SkyFunctionName.createHermetic("REGISTERED_TOOLCHAINS");
   static final SkyFunctionName SINGLE_TOOLCHAIN_RESOLUTION =
       SkyFunctionName.createHermetic("SINGLE_TOOLCHAIN_RESOLUTION");
-  static final SkyFunctionName TOOLCHAIN_RESOLUTION =
+  public static final SkyFunctionName TOOLCHAIN_RESOLUTION =
       SkyFunctionName.createHermetic("TOOLCHAIN_RESOLUTION");
   public static final SkyFunctionName REPOSITORY_MAPPING =
       SkyFunctionName.createHermetic("REPOSITORY_MAPPING");
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
index d39d838..d2bf860 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
@@ -93,7 +93,6 @@
       // Determine the actual toolchain implementations to use.
       determineToolchainImplementations(
           env,
-          debug,
           key.configurationKey(),
           key.requiredToolchainTypeLabels(),
           builder,
@@ -275,7 +274,7 @@
             .handle(
                 Event.info(
                     String.format(
-                        "ToolchainResolver: Removed execution platform %s from"
+                        "ToolchainResolution: Removed execution platform %s from"
                             + " available execution platforms, it is missing constraint %s",
                         platformInfo.label(), constraint.label())));
       }
@@ -285,8 +284,7 @@
   }
 
   private void determineToolchainImplementations(
-      SkyFunction.Environment environment,
-      boolean debug,
+      Environment environment,
       BuildConfigurationValue.Key configurationKey,
       ImmutableSet<Label> requiredToolchainTypeLabels,
       UnloadedToolchainContext.Builder builder,
@@ -358,8 +356,6 @@
     if (!requiredToolchainTypeLabels.isEmpty()) {
       selectedExecutionPlatformKey =
           findExecutionPlatformForToolchains(
-              environment,
-              debug,
               requiredToolchainTypes,
               platformKeys.executionPlatformKeys(),
               resolvedToolchains);
@@ -400,7 +396,7 @@
   }
 
   /**
-   * Adds all of toolchain labels from{@code toolchainResolutionValue} to {@code
+   * Adds all of toolchain labels from {@code toolchainResolutionValue} to {@code
    * resolvedToolchains}.
    */
   private static Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> findPlatformsAndLabels(
@@ -421,8 +417,6 @@
    * resolvedToolchains} and has all required toolchain types.
    */
   private static Optional<ConfiguredTargetKey> findExecutionPlatformForToolchains(
-      SkyFunction.Environment environment,
-      boolean debug,
       ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes,
       ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys,
       Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains) {
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/ToolchainResolverTest.java b/src/test/java/com/google/devtools/build/lib/analysis/ToolchainResolverTest.java
deleted file mode 100644
index f50a399..0000000
--- a/src/test/java/com/google/devtools/build/lib/analysis/ToolchainResolverTest.java
+++ /dev/null
@@ -1,521 +0,0 @@
-// Copyright 2018 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;
-
-import static com.google.common.truth.Truth.assertThat;
-import static com.google.devtools.build.skyframe.EvaluationResultSubjectFactory.assertThatEvaluationResult;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.devtools.build.lib.analysis.ToolchainResolver.NoMatchingPlatformException;
-import com.google.devtools.build.lib.analysis.ToolchainResolver.UnresolvedToolchainsException;
-import com.google.devtools.build.lib.analysis.util.AnalysisMock;
-import com.google.devtools.build.lib.cmdline.Label;
-import com.google.devtools.build.lib.rules.platform.ToolchainTestCase;
-import com.google.devtools.build.lib.skyframe.BuildConfigurationValue;
-import com.google.devtools.build.lib.skyframe.ConstraintValueLookupUtil.InvalidConstraintValueException;
-import com.google.devtools.build.lib.skyframe.PlatformLookupUtil.InvalidPlatformException;
-import com.google.devtools.build.lib.skyframe.ToolchainException;
-import com.google.devtools.build.lib.skyframe.UnloadedToolchainContext;
-import com.google.devtools.build.lib.skyframe.util.SkyframeExecutorTestUtils;
-import com.google.devtools.build.skyframe.EvaluationResult;
-import com.google.devtools.build.skyframe.SkyFunction;
-import com.google.devtools.build.skyframe.SkyFunctionException;
-import com.google.devtools.build.skyframe.SkyFunctionName;
-import com.google.devtools.build.skyframe.SkyKey;
-import com.google.devtools.build.skyframe.SkyValue;
-import java.util.Set;
-import javax.annotation.Nullable;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Tests for {@link ToolchainResolver}. */
-@RunWith(JUnit4.class)
-public class ToolchainResolverTest extends ToolchainTestCase {
-  /**
-   * An {@link AnalysisMock} that injects {@link ResolveToolchainsFunction} into the Skyframe
-   * executor.
-   */
-  private static final class LocalAnalysisMock extends AnalysisMock.Delegate {
-    LocalAnalysisMock() {
-      super(AnalysisMock.get());
-    }
-
-    @Override
-    public ImmutableMap<SkyFunctionName, SkyFunction> getSkyFunctions(
-        BlazeDirectories directories) {
-      return ImmutableMap.<SkyFunctionName, SkyFunction>builder()
-          .putAll(super.getSkyFunctions(directories))
-          .put(RESOLVE_TOOLCHAINS_FUNCTION, new ResolveToolchainsFunction())
-          .build();
-    }
-  }
-
-  @Override
-  protected AnalysisMock getAnalysisMock() {
-    return new LocalAnalysisMock();
-  }
-
-  @Test
-  public void resolve() throws Exception {
-    // This should select platform mac, toolchain extra_toolchain_mac, because platform
-    // mac is listed first.
-    addToolchain(
-        "extra",
-        "extra_toolchain_linux",
-        ImmutableList.of("//constraints:linux"),
-        ImmutableList.of("//constraints:linux"),
-        "baz");
-    addToolchain(
-        "extra",
-        "extra_toolchain_mac",
-        ImmutableList.of("//constraints:mac"),
-        ImmutableList.of("//constraints:linux"),
-        "baz");
-    rewriteWorkspace(
-        "register_toolchains('//extra:extra_toolchain_linux', '//extra:extra_toolchain_mac')",
-        "register_execution_platforms('//platforms:mac', '//platforms:linux')");
-
-    useConfiguration("--platforms=//platforms:linux");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(ImmutableSet.of(testToolchainTypeLabel), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasNoError();
-    UnloadedToolchainContext unloadedToolchainContext = result.get(key).unloadedToolchainContext();
-    assertThat(unloadedToolchainContext).isNotNull();
-
-    assertThat(unloadedToolchainContext.requiredToolchainTypes())
-        .containsExactly(testToolchainType);
-    assertThat(unloadedToolchainContext.resolvedToolchainLabels())
-        .containsExactly(Label.parseAbsoluteUnchecked("//extra:extra_toolchain_mac_impl"));
-
-    assertThat(unloadedToolchainContext.executionPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.executionPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:mac"));
-
-    assertThat(unloadedToolchainContext.targetPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.targetPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
-  }
-
-  @Test
-  public void resolve_noToolchainType() throws Exception {
-    scratch.file("host/BUILD", "platform(name = 'host')");
-    rewriteWorkspace("register_execution_platforms('//platforms:mac', '//platforms:linux')");
-
-    useConfiguration("--host_platform=//host:host", "--platforms=//platforms:linux");
-    ResolveToolchainsKey key = ResolveToolchainsKey.create(ImmutableSet.of(), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasNoError();
-    UnloadedToolchainContext unloadedToolchainContext = result.get(key).unloadedToolchainContext();
-    assertThat(unloadedToolchainContext).isNotNull();
-
-    assertThat(unloadedToolchainContext.requiredToolchainTypes()).isEmpty();
-
-    // With no toolchains requested, should fall back to the host platform.
-    assertThat(unloadedToolchainContext.executionPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.executionPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//host:host"));
-
-    assertThat(unloadedToolchainContext.targetPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.targetPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
-  }
-
-  @Test
-  public void resolve_noToolchainType_hostNotAvailable() throws Exception {
-    scratch.file("host/BUILD", "platform(name = 'host')");
-    scratch.file(
-        "sample/BUILD",
-        "constraint_setting(name='demo')",
-        "constraint_value(name = 'demo_a', constraint_setting=':demo')",
-        "constraint_value(name = 'demo_b', constraint_setting=':demo')",
-        "platform(name = 'sample_a',",
-        "  constraint_values = [':demo_a'],",
-        ")",
-        "platform(name = 'sample_b',",
-        "  constraint_values = [':demo_b'],",
-        ")");
-    rewriteWorkspace(
-        "register_execution_platforms('//platforms:mac', '//platforms:linux',",
-        "    '//sample:sample_a', '//sample:sample_b')");
-
-    useConfiguration("--host_platform=//host:host", "--platforms=//platforms:linux");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(),
-            ImmutableSet.of(Label.parseAbsoluteUnchecked("//sample:demo_b")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasNoError();
-    UnloadedToolchainContext unloadedToolchainContext = result.get(key).unloadedToolchainContext();
-    assertThat(unloadedToolchainContext).isNotNull();
-
-    assertThat(unloadedToolchainContext.requiredToolchainTypes()).isEmpty();
-
-    assertThat(unloadedToolchainContext.executionPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.executionPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//sample:sample_b"));
-
-    assertThat(unloadedToolchainContext.targetPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.targetPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
-  }
-
-  @Test
-  public void resolve_unavailableToolchainType_single() throws Exception {
-    useConfiguration("--host_platform=//platforms:linux", "--platforms=//platforms:mac");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(
-                testToolchainTypeLabel, Label.parseAbsoluteUnchecked("//fake/toolchain:type_1")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(UnresolvedToolchainsException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains("no matching toolchains found for types //fake/toolchain:type_1");
-  }
-
-  @Test
-  public void resolve_unavailableToolchainType_multiple() throws Exception {
-    useConfiguration("--host_platform=//platforms:linux", "--platforms=//platforms:mac");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(
-                testToolchainTypeLabel,
-                Label.parseAbsoluteUnchecked("//fake/toolchain:type_1"),
-                Label.parseAbsoluteUnchecked("//fake/toolchain:type_2")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(UnresolvedToolchainsException.class);
-    // Only one of the missing types will be reported, so do not check the specific error message.
-  }
-
-  @Test
-  public void resolve_invalidTargetPlatform_badTarget() throws Exception {
-    scratch.file("invalid/BUILD", "filegroup(name = 'not_a_platform')");
-    useConfiguration("--platforms=//invalid:not_a_platform");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(ImmutableSet.of(testToolchainTypeLabel), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(InvalidPlatformException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains(
-            "//invalid:not_a_platform was referenced as a platform, "
-                + "but does not provide PlatformInfo");
-  }
-
-  @Test
-  public void resolve_invalidTargetPlatform_badPackage() throws Exception {
-    scratch.resolve("invalid").delete();
-    useConfiguration("--platforms=//invalid:not_a_platform");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(ImmutableSet.of(testToolchainTypeLabel), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(InvalidPlatformException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains("BUILD file not found");
-  }
-
-  @Test
-  public void resolve_invalidHostPlatform() throws Exception {
-    scratch.file("invalid/BUILD", "filegroup(name = 'not_a_platform')");
-    useConfiguration("--host_platform=//invalid:not_a_platform");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(ImmutableSet.of(testToolchainTypeLabel), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(InvalidPlatformException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains("//invalid:not_a_platform");
-  }
-
-  @Test
-  public void resolve_invalidExecutionPlatform() throws Exception {
-    scratch.file("invalid/BUILD", "filegroup(name = 'not_a_platform')");
-    useConfiguration("--extra_execution_platforms=//invalid:not_a_platform");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(ImmutableSet.of(testToolchainTypeLabel), targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(InvalidPlatformException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains("//invalid:not_a_platform");
-  }
-
-  @Test
-  public void resolve_execConstraints() throws Exception {
-    // This should select platform linux, toolchain extra_toolchain_linux, due to extra constraints,
-    // even though platform mac is registered first.
-    addToolchain(
-        /* packageName= */ "extra",
-        /* toolchainName= */ "extra_toolchain_linux",
-        /* execConstraints= */ ImmutableList.of("//constraints:linux"),
-        /* targetConstraints= */ ImmutableList.of("//constraints:linux"),
-        /* data= */ "baz");
-    addToolchain(
-        /* packageName= */ "extra",
-        /* toolchainName= */ "extra_toolchain_mac",
-        /* execConstraints= */ ImmutableList.of("//constraints:mac"),
-        /* targetConstraints= */ ImmutableList.of("//constraints:linux"),
-        /* data= */ "baz");
-    rewriteWorkspace(
-        "register_toolchains('//extra:extra_toolchain_linux', '//extra:extra_toolchain_mac')",
-        "register_execution_platforms('//platforms:mac', '//platforms:linux')");
-
-    useConfiguration("--platforms=//platforms:linux");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(testToolchainTypeLabel),
-            ImmutableSet.of(Label.parseAbsoluteUnchecked("//constraints:linux")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasNoError();
-    UnloadedToolchainContext unloadedToolchainContext = result.get(key).unloadedToolchainContext();
-    assertThat(unloadedToolchainContext).isNotNull();
-
-    assertThat(unloadedToolchainContext.requiredToolchainTypes())
-        .containsExactly(testToolchainType);
-    assertThat(unloadedToolchainContext.resolvedToolchainLabels())
-        .containsExactly(Label.parseAbsoluteUnchecked("//extra:extra_toolchain_linux_impl"));
-
-    assertThat(unloadedToolchainContext.executionPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.executionPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
-
-    assertThat(unloadedToolchainContext.targetPlatform()).isNotNull();
-    assertThat(unloadedToolchainContext.targetPlatform().label())
-        .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
-  }
-
-  @Test
-  public void resolve_execConstraints_invalid() throws Exception {
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(testToolchainTypeLabel),
-            ImmutableSet.of(Label.parseAbsoluteUnchecked("//platforms:linux")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(InvalidConstraintValueException.class);
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .hasMessageThat()
-        .contains("//platforms:linux");
-  }
-
-  @Test
-  public void resolve_noMatchingPlatform() throws Exception {
-    // Write toolchain A, and a toolchain implementing it.
-    scratch.appendFile(
-        "a/BUILD",
-        "toolchain_type(name = 'toolchain_type_A')",
-        "toolchain(",
-        "    name = 'toolchain',",
-        "    toolchain_type = ':toolchain_type_A',",
-        "    exec_compatible_with = ['//constraints:mac'],",
-        "    target_compatible_with = [],",
-        "    toolchain = ':toolchain_impl')",
-        "filegroup(name='toolchain_impl')");
-    // Write toolchain B, and a toolchain implementing it.
-    scratch.appendFile(
-        "b/BUILD",
-        "load('//toolchain:toolchain_def.bzl', 'test_toolchain')",
-        "toolchain_type(name = 'toolchain_type_B')",
-        "toolchain(",
-        "    name = 'toolchain',",
-        "    toolchain_type = ':toolchain_type_B',",
-        "    exec_compatible_with = ['//constraints:linux'],",
-        "    target_compatible_with = [],",
-        "    toolchain = ':toolchain_impl')",
-        "filegroup(name='toolchain_impl')");
-
-    rewriteWorkspace(
-        "register_toolchains('//a:toolchain', '//b:toolchain')",
-        "register_execution_platforms('//platforms:mac', '//platforms:linux')");
-
-    useConfiguration("--platforms=//platforms:linux");
-    ResolveToolchainsKey key =
-        ResolveToolchainsKey.create(
-            ImmutableSet.of(
-                Label.parseAbsoluteUnchecked("//a:toolchain_type_A"),
-                Label.parseAbsoluteUnchecked("//b:toolchain_type_B")),
-            targetConfigKey);
-
-    EvaluationResult<ResolveToolchainsValue> result = createToolchainContextBuilder(key);
-    assertThatEvaluationResult(result).hasError();
-    assertThatEvaluationResult(result)
-        .hasErrorEntryForKeyThat(key)
-        .hasExceptionThat()
-        .isInstanceOf(NoMatchingPlatformException.class);
-  }
-
-  private static final SkyFunctionName RESOLVE_TOOLCHAINS_FUNCTION =
-      SkyFunctionName.createHermetic("RESOLVE_TOOLCHAINS_FUNCTION");
-
-  @AutoValue
-  abstract static class ResolveToolchainsKey implements SkyKey {
-    @Override
-    public SkyFunctionName functionName() {
-      return RESOLVE_TOOLCHAINS_FUNCTION;
-    }
-
-    abstract ImmutableSet<Label> requiredToolchainTypes();
-
-    abstract ImmutableSet<Label> execConstraintLabels();
-
-    abstract BuildConfigurationValue.Key configurationKey();
-
-    public static ResolveToolchainsKey create(
-        Set<Label> requiredToolchains,
-        BuildConfigurationValue.Key configurationKey) {
-      return create(
-          requiredToolchains,
-          /* execConstraintLabels= */ ImmutableSet.of(),
-          configurationKey);
-    }
-
-    public static ResolveToolchainsKey create(
-        Set<Label> requiredToolchains,
-        Set<Label> execConstraintLabels,
-        BuildConfigurationValue.Key configurationKey) {
-      return new AutoValue_ToolchainResolverTest_ResolveToolchainsKey(
-          ImmutableSet.copyOf(requiredToolchains),
-          ImmutableSet.copyOf(execConstraintLabels),
-          configurationKey);
-    }
-  }
-
-  private EvaluationResult<ResolveToolchainsValue> createToolchainContextBuilder(
-      ResolveToolchainsKey key) throws InterruptedException {
-    try {
-      // Must re-enable analysis for Skyframe functions that create configured targets.
-      skyframeExecutor.getSkyframeBuildView().enableAnalysis(true);
-      return SkyframeExecutorTestUtils.evaluate(
-          skyframeExecutor, key, /*keepGoing=*/ false, reporter);
-    } finally {
-      skyframeExecutor.getSkyframeBuildView().enableAnalysis(false);
-    }
-  }
-
-  @AutoValue
-  abstract static class ResolveToolchainsValue implements SkyValue {
-    abstract UnloadedToolchainContext unloadedToolchainContext();
-
-    static ResolveToolchainsValue create(UnloadedToolchainContext unloadedToolchainContext) {
-      return new AutoValue_ToolchainResolverTest_ResolveToolchainsValue(unloadedToolchainContext);
-    }
-  }
-
-  private static final class ResolveToolchainsFunction implements SkyFunction {
-
-    @Nullable
-    @Override
-    public SkyValue compute(SkyKey skyKey, Environment env)
-        throws SkyFunctionException, InterruptedException {
-      ResolveToolchainsKey key = (ResolveToolchainsKey) skyKey;
-      ToolchainResolver toolchainResolver =
-          new ToolchainResolver(env, key.configurationKey())
-              .setRequiredToolchainTypes(key.requiredToolchainTypes())
-              .setExecConstraintLabels(key.execConstraintLabels());
-
-      try {
-        UnloadedToolchainContext unloadedToolchainContext = toolchainResolver.resolve();
-        if (unloadedToolchainContext == null) {
-          return null;
-        }
-        return ResolveToolchainsValue.create(unloadedToolchainContext);
-      } catch (ToolchainException e) {
-        throw new ResolveToolchainsFunctionException(e);
-      }
-    }
-
-    @Nullable
-    @Override
-    public String extractTag(SkyKey skyKey) {
-      return null;
-    }
-  }
-
-  private static class ResolveToolchainsFunctionException extends SkyFunctionException {
-    ResolveToolchainsFunctionException(ToolchainException e) {
-      super(e, Transience.PERSISTENT);
-    }
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewForTesting.java b/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewForTesting.java
index c99c79a..b267e88 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewForTesting.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewForTesting.java
@@ -41,7 +41,6 @@
 import com.google.devtools.build.lib.analysis.ResolvedToolchainContext;
 import com.google.devtools.build.lib.analysis.RuleContext;
 import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
-import com.google.devtools.build.lib.analysis.ToolchainResolver;
 import com.google.devtools.build.lib.analysis.TopLevelArtifactContext;
 import com.google.devtools.build.lib.analysis.ViewCreationFailedException;
 import com.google.devtools.build.lib.analysis.WorkspaceStatusAction;
@@ -494,9 +493,13 @@
     SkyFunctionEnvironmentForTesting skyfunctionEnvironment =
         skyframeExecutor.getSkyFunctionEnvironmentForTesting(eventHandler);
     UnloadedToolchainContext unloadedToolchainContext =
-        new ToolchainResolver(skyfunctionEnvironment, BuildConfigurationValue.key(targetConfig))
-            .setRequiredToolchainTypes(requiredToolchains)
-            .resolve();
+        (UnloadedToolchainContext)
+            skyfunctionEnvironment.getValueOrThrow(
+                UnloadedToolchainContext.key()
+                    .configurationKey(BuildConfigurationValue.key(targetConfig))
+                    .requiredToolchainTypeLabels(requiredToolchains)
+                    .build(),
+                ToolchainException.class);
 
     OrderedSetMultimap<DependencyKind, ConfiguredTargetAndData> prerequisiteMap =
         getPrerequisiteMapForTesting(
diff --git a/src/test/shell/bazel/toolchain_test.sh b/src/test/shell/bazel/toolchain_test.sh
index 7eedb4e..44c6f24 100755
--- a/src/test/shell/bazel/toolchain_test.sh
+++ b/src/test/shell/bazel/toolchain_test.sh
@@ -441,7 +441,7 @@
     //demo:use &> $TEST_log || fail "Build failed"
   expect_log 'ToolchainResolution: Looking for toolchain of type //toolchain:test_toolchain'
   expect_log 'ToolchainResolution:   For toolchain type //toolchain:test_toolchain, possible execution platforms and toolchains: {@local_config_platform//:host -> //:test_toolchain_impl_1}'
-  expect_log 'ToolchainResolver: Selected execution platform @local_config_platform//:host, type //toolchain:test_toolchain -> toolchain //:test_toolchain_impl_1'
+  expect_log 'ToolchainResolution: Selected execution platform @local_config_platform//:host, type //toolchain:test_toolchain -> toolchain //:test_toolchain_impl_1'
   expect_log 'Using toolchain: rule message: "this is the rule", toolchain extra_str: "foo from test_toolchain"'
 }
 
@@ -820,7 +820,7 @@
     --extra_execution_platforms=//platform:test_platform \
     --toolchain_resolution_debug \
     //demo:target &> $TEST_log || fail "Build failed"
-  expect_log "ToolchainResolver: Selected execution platform //platform:test_platform"
+  expect_log "ToolchainResolution: Selected execution platform //platform:test_platform"
 }