From 004099d17e92a09dc4f7c920e6d54bbe2e67d3fb Mon Sep 17 00:00:00 2001
From: John Cater <jcater@google.com>
Date: Fri, 17 May 2019 11:21:59 -0700
Subject: [PATCH] Update toolchain resolution to load requested toolchain
 types.

This allows Bazel to validate toolchain types earleir, and to deal with
aliases to toolchain types.

Fixes #7404.

Closes #8381.

PiperOrigin-RevId: 248755418
---
 .../analysis/ResolvedToolchainContext.java    |  32 +--
 .../skyframe/ToolchainResolutionFunction.java |  40 +++-
 .../lib/skyframe/ToolchainTypeLookupUtil.java | 152 ++++++++++++
 .../skyframe/UnloadedToolchainContext.java    |  24 +-
 .../ResolvedToolchainContextTest.java         |  53 ++++-
 .../ToolchainResolutionFunctionTest.java      |  54 ++++-
 .../skyframe/ToolchainTypeLookupUtilTest.java | 225 ++++++++++++++++++
 src/test/shell/bazel/toolchain_test.sh        |  94 ++++++++
 8 files changed, 650 insertions(+), 24 deletions(-)
 create mode 100644 src/main/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtil.java
 create mode 100644 src/test/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtilTest.java

diff --git a/src/main/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContext.java b/src/main/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContext.java
index 9a19b105fe3353..9ecc4106d3094f 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContext.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContext.java
@@ -38,7 +38,6 @@
 import com.google.devtools.build.lib.skylarkinterface.StarlarkContext;
 import com.google.devtools.build.lib.syntax.EvalException;
 import com.google.devtools.build.lib.syntax.EvalUtils;
-import java.util.Optional;
 import java.util.Set;
 import javax.annotation.Nullable;
 
@@ -67,7 +66,9 @@ public static ResolvedToolchainContext load(
             .setExecutionPlatform(unloadedToolchainContext.executionPlatform())
             .setTargetPlatform(unloadedToolchainContext.targetPlatform())
             .setRequiredToolchainTypes(unloadedToolchainContext.requiredToolchainTypes())
-            .setResolvedToolchainLabels(unloadedToolchainContext.resolvedToolchainLabels());
+            .setResolvedToolchainLabels(unloadedToolchainContext.resolvedToolchainLabels())
+            .setRequestedToolchainTypeLabels(
+                unloadedToolchainContext.requestedLabelToToolchainType());
 
     ImmutableMap.Builder<ToolchainTypeInfo, ToolchainInfo> toolchains =
         new ImmutableMap.Builder<>();
@@ -126,6 +127,10 @@ interface Builder {
     /** Sets the toolchain types that were requested. */
     Builder setRequiredToolchainTypes(Set<ToolchainTypeInfo> requiredToolchainTypes);
 
+    /** Sets the map from requested {@link Label} to toolchain type provider. */
+    Builder setRequestedToolchainTypeLabels(
+        ImmutableMap<Label, ToolchainTypeInfo> requestedToolchainTypeLabels);
+
     /** Sets the map from toolchain type to toolchain provider. */
     Builder setToolchains(ImmutableMap<ToolchainTypeInfo, ToolchainInfo> toolchains);
 
@@ -142,6 +147,9 @@ interface Builder {
   /** Returns a description of the target being used, for error messaging. */
   abstract String targetDescription();
 
+  /** Sets the map from requested {@link Label} to toolchain type provider. */
+  abstract ImmutableMap<Label, ToolchainTypeInfo> requestedToolchainTypeLabels();
+
   abstract ImmutableMap<ToolchainTypeInfo, ToolchainInfo> toolchains();
 
   /** Returns the template variables that these toolchains provide. */
@@ -153,15 +161,11 @@ interface Builder {
    */
   @Nullable
   public ToolchainInfo forToolchainType(Label toolchainTypeLabel) {
-    Optional<ToolchainTypeInfo> toolchainType =
-        toolchains().keySet().stream()
-            .filter(info -> info.typeLabel().equals(toolchainTypeLabel))
-            .findFirst();
-    if (toolchainType.isPresent()) {
-      return forToolchainType(toolchainType.get());
-    } else {
+    ToolchainTypeInfo toolchainTypeInfo = requestedToolchainTypeLabels().get(toolchainTypeLabel);
+    if (toolchainTypeInfo == null) {
       return null;
     }
+    return toolchains().get(toolchainTypeInfo);
   }
 
   @Nullable
@@ -215,6 +219,9 @@ public ToolchainInfo getIndex(Object key, Location loc, StarlarkContext context)
     Label toolchainTypeLabel = transformKey(key, loc);
 
     if (!containsKey(key, loc, context)) {
+      // TODO(bazel-configurability): The list of available toolchain types is confusing in the
+      // presence of aliases, since it only contains the actual label, not the alias passed to the
+      // rule definition.
       throw new EvalException(
           loc,
           String.format(
@@ -233,12 +240,7 @@ public ToolchainInfo getIndex(Object key, Location loc, StarlarkContext context)
   public boolean containsKey(Object key, Location loc, StarlarkContext context)
       throws EvalException {
     Label toolchainTypeLabel = transformKey(key, loc);
-    Optional<Label> matching =
-        toolchains().keySet().stream()
-            .map(ToolchainTypeInfo::typeLabel)
-            .filter(label -> label.equals(toolchainTypeLabel))
-            .findAny();
-    return matching.isPresent();
+    return requestedToolchainTypeLabels().containsKey(toolchainTypeLabel);
   }
 
   /**
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 d2bf860fc21813..8da6903d7d46e4 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
@@ -14,6 +14,7 @@
 package com.google.devtools.build.lib.skyframe;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static java.util.stream.Collectors.joining;
 
 import com.google.auto.value.AutoValue;
@@ -21,6 +22,7 @@
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.ImmutableBiMap;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Table;
 import com.google.devtools.build.lib.analysis.PlatformConfiguration;
@@ -35,6 +37,7 @@
 import com.google.devtools.build.lib.skyframe.PlatformLookupUtil.InvalidPlatformException;
 import com.google.devtools.build.lib.skyframe.RegisteredToolchainsFunction.InvalidToolchainLabelException;
 import com.google.devtools.build.lib.skyframe.SingleToolchainResolutionFunction.NoToolchainFoundException;
+import com.google.devtools.build.lib.skyframe.ToolchainTypeLookupUtil.InvalidToolchainTypeException;
 import com.google.devtools.build.skyframe.SkyFunction;
 import com.google.devtools.build.skyframe.SkyFunctionException;
 import com.google.devtools.build.skyframe.SkyKey;
@@ -76,6 +79,20 @@ public UnloadedToolchainContext compute(SkyKey skyKey, Environment env)
       boolean debug =
           configuration.getOptions().get(PlatformOptions.class).toolchainResolutionDebug;
 
+      // Load the configured target for the toolchain types to ensure that they are valid and
+      // resolve aliases.
+      ImmutableMap<Label, ToolchainTypeInfo> resolvedToolchainTypes =
+          loadToolchainTypes(
+              env,
+              configuration,
+              key.requiredToolchainTypeLabels(),
+              key.shouldSanityCheckConfiguration());
+      builder.setRequestedLabelToToolchainType(resolvedToolchainTypes);
+      ImmutableSet<Label> resolvedToolchainTypeLabels =
+          resolvedToolchainTypes.values().stream()
+              .map(ToolchainTypeInfo::typeLabel)
+              .collect(toImmutableSet());
+
       // Create keys for all platforms that will be used, and validate them early.
       PlatformKeys platformKeys =
           loadPlatformKeys(
@@ -94,7 +111,7 @@ public UnloadedToolchainContext compute(SkyKey skyKey, Environment env)
       determineToolchainImplementations(
           env,
           key.configurationKey(),
-          key.requiredToolchainTypeLabels(),
+          resolvedToolchainTypeLabels,
           builder,
           platformKeys,
           key.shouldSanityCheckConfiguration());
@@ -123,6 +140,27 @@ public UnloadedToolchainContext compute(SkyKey skyKey, Environment env)
     }
   }
 
+  /** Returns a map from the requested toolchain type to the {@link ToolchainTypeInfo} provider. */
+  private ImmutableMap<Label, ToolchainTypeInfo> loadToolchainTypes(
+      Environment environment,
+      BuildConfiguration configuration,
+      ImmutableSet<Label> requestedToolchainTypeLabels,
+      boolean shouldSanityCheckConfiguration)
+      throws InvalidToolchainTypeException, InterruptedException, ValueMissingException {
+    ImmutableSet<ConfiguredTargetKey> toolchainTypeKeys =
+        requestedToolchainTypeLabels.stream()
+            .map(label -> ConfiguredTargetKey.of(label, configuration))
+            .collect(toImmutableSet());
+
+    ImmutableMap<Label, ToolchainTypeInfo> resolvedToolchainTypes =
+        ToolchainTypeLookupUtil.resolveToolchainTypes(
+            environment, toolchainTypeKeys, shouldSanityCheckConfiguration);
+    if (environment.valuesMissing()) {
+      throw new ValueMissingException();
+    }
+    return resolvedToolchainTypes;
+  }
+
   @AutoValue
   abstract static class PlatformKeys {
     abstract ConfiguredTargetKey hostPlatformKey();
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtil.java b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtil.java
new file mode 100644
index 00000000000000..4a34bbe11704da
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtil.java
@@ -0,0 +1,152 @@
+// Copyright 2019 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.skyframe;
+
+import static java.util.stream.Collectors.joining;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
+import com.google.devtools.build.lib.analysis.ConfiguredTarget;
+import com.google.devtools.build.lib.analysis.platform.PlatformProviderUtils;
+import com.google.devtools.build.lib.analysis.platform.ToolchainTypeInfo;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.packages.NoSuchThingException;
+import com.google.devtools.build.lib.skyframe.ConfiguredTargetFunction.ConfiguredValueCreationException;
+import com.google.devtools.build.skyframe.SkyFunction.Environment;
+import com.google.devtools.build.skyframe.SkyKey;
+import com.google.devtools.build.skyframe.ValueOrException3;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Helper class that looks up {@link ToolchainTypeInfo} data. */
+public class ToolchainTypeLookupUtil {
+
+  @Nullable
+  public static ImmutableMap<Label, ToolchainTypeInfo> resolveToolchainTypes(
+      Environment env,
+      Iterable<ConfiguredTargetKey> toolchainTypeKeys,
+      boolean sanityCheckConfiguration)
+      throws InterruptedException, InvalidToolchainTypeException {
+    Map<
+            SkyKey,
+            ValueOrException3<
+                ConfiguredValueCreationException, NoSuchThingException, ActionConflictException>>
+        values =
+            env.getValuesOrThrow(
+                toolchainTypeKeys,
+                ConfiguredValueCreationException.class,
+                NoSuchThingException.class,
+                ActionConflictException.class);
+    boolean valuesMissing = env.valuesMissing();
+    Map<Label, ToolchainTypeInfo> results = valuesMissing ? null : new HashMap<>();
+    for (ConfiguredTargetKey key : toolchainTypeKeys) {
+      Label originalLabel = key.getLabel();
+      ToolchainTypeInfo toolchainTypeInfo =
+          findToolchainTypeInfo(key, values.get(key), sanityCheckConfiguration);
+      if (!valuesMissing && toolchainTypeInfo != null) {
+        // These are only different if the toolchain type was aliased.
+        results.put(originalLabel, toolchainTypeInfo);
+        results.put(toolchainTypeInfo.typeLabel(), toolchainTypeInfo);
+      }
+    }
+    if (valuesMissing) {
+      return null;
+    }
+
+    return ImmutableMap.copyOf(results);
+  }
+
+  @Nullable
+  private static ToolchainTypeInfo findToolchainTypeInfo(
+      ConfiguredTargetKey key,
+      ValueOrException3<
+              ConfiguredValueCreationException, NoSuchThingException, ActionConflictException>
+          valueOrException,
+      boolean sanityCheckConfiguration)
+      throws InvalidToolchainTypeException {
+
+    try {
+      ConfiguredTargetValue ctv = (ConfiguredTargetValue) valueOrException.get();
+      if (ctv == null) {
+        return null;
+      }
+
+      ConfiguredTarget configuredTarget = ctv.getConfiguredTarget();
+      BuildConfigurationValue.Key configurationKey = configuredTarget.getConfigurationKey();
+      // This check is necessary because trimming for other rules assumes that platform resolution
+      // uses the platform fragment and _only_ the platform fragment. Without this check, it's
+      // possible another fragment could slip in without us realizing, and thus break this
+      // assumption.
+      if (sanityCheckConfiguration && !configurationKey.getFragments().isEmpty()) {
+        // No fragments may be present on a toolchain_type rule in retroactive
+        // trimming mode.
+        String extraFragmentDescription =
+            configurationKey.getFragments().stream()
+                .map(cl -> cl.getSimpleName())
+                .collect(joining(","));
+        throw new InvalidToolchainTypeException(
+            configuredTarget.getLabel(),
+            "has configuration fragments, "
+                + "which is forbidden in retroactive trimming mode: "
+                + "extra fragments are ["
+                + extraFragmentDescription
+                + "]");
+      }
+      ToolchainTypeInfo toolchainTypeInfo = PlatformProviderUtils.toolchainType(configuredTarget);
+      if (toolchainTypeInfo == null) {
+        throw new InvalidToolchainTypeException(configuredTarget.getLabel());
+      }
+
+      return toolchainTypeInfo;
+    } catch (ConfiguredValueCreationException e) {
+      throw new InvalidToolchainTypeException(key.getLabel(), e);
+    } catch (NoSuchThingException e) {
+      throw new InvalidToolchainTypeException(key.getLabel(), e);
+    } catch (ActionConflictException e) {
+      throw new InvalidToolchainTypeException(key.getLabel(), e);
+    }
+  }
+
+  /** Exception used when a toolchain type label is not a valid toolchain type. */
+  public static final class InvalidToolchainTypeException extends ToolchainException {
+    private static final String DEFAULT_ERROR = "does not provide ToolchainTypeInfo";
+
+    InvalidToolchainTypeException(Label label) {
+      super(formatError(label, DEFAULT_ERROR));
+    }
+
+    InvalidToolchainTypeException(Label label, ConfiguredValueCreationException e) {
+      super(formatError(label, DEFAULT_ERROR), e);
+    }
+
+    public InvalidToolchainTypeException(Label label, NoSuchThingException e) {
+      // Just propagate the inner exception, because it's directly actionable.
+      super(e);
+    }
+
+    public InvalidToolchainTypeException(Label label, ActionConflictException e) {
+      super(formatError(label, DEFAULT_ERROR), e);
+    }
+
+    InvalidToolchainTypeException(Label label, String error) {
+      super(formatError(label, error));
+    }
+
+    private static String formatError(Label label, String error) {
+      return String.format("Target %s was referenced as a toolchain type, but %s", label, error);
+    }
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/UnloadedToolchainContext.java b/src/main/java/com/google/devtools/build/lib/skyframe/UnloadedToolchainContext.java
index cad4345644bb8f..e1b137445fee0a 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/UnloadedToolchainContext.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/UnloadedToolchainContext.java
@@ -15,6 +15,7 @@
 
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.devtools.build.lib.analysis.ToolchainContext;
 import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
@@ -92,16 +93,37 @@ public interface Builder {
     /** Sets the toolchain types that were requested. */
     Builder setRequiredToolchainTypes(Set<ToolchainTypeInfo> requiredToolchainTypes);
 
+    /**
+     * Maps from the actual toolchain type to the resolved toolchain implementation that should be
+     * used.
+     */
     Builder setToolchainTypeToResolved(
         ImmutableBiMap<ToolchainTypeInfo, Label> toolchainTypeToResolved);
 
+    /**
+     * Maps from the actual requested {@link Label} to the discovered {@link ToolchainTypeInfo}.
+     *
+     * <p>Note that the key may be different from {@link ToolchainTypeInfo#typeLabel()} if the
+     * requested {@link Label} is an {@code alias}.
+     */
+    Builder setRequestedLabelToToolchainType(
+        ImmutableMap<Label, ToolchainTypeInfo> requestedLabelToToolchainType);
+
     UnloadedToolchainContext build();
   }
 
   /** The map of toolchain type to resolved toolchain to be used. */
-  // TODO(https://github.com/bazelbuild/bazel/issues/7935): Make this package-protected again.
   public abstract ImmutableBiMap<ToolchainTypeInfo, Label> toolchainTypeToResolved();
 
+  /**
+   * Maps from the actual requested {@link Label} to the discovered {@link ToolchainTypeInfo}.
+   *
+   * <p>Note that the key may be different from {@link ToolchainTypeInfo#typeLabel()} if the
+   * requested {@link Label} is an {@code alias}. In this case, there will be two {@link Label
+   * labels} for the same {@link ToolchainTypeInfo}.
+   */
+  public abstract ImmutableMap<Label, ToolchainTypeInfo> requestedLabelToToolchainType();
+
   @Override
   public ImmutableSet<Label> resolvedToolchainLabels() {
     return toolchainTypeToResolved().values();
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContextTest.java b/src/test/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContextTest.java
index 863aa885f9ffd6..77e3932f205d11 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContextTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/ResolvedToolchainContextTest.java
@@ -18,6 +18,7 @@
 
 import com.google.common.collect.ImmutableBiMap;
 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.platform.ToolchainTypeInfo;
 import com.google.devtools.build.lib.cmdline.Label;
@@ -34,7 +35,7 @@
 public class ResolvedToolchainContextTest extends ToolchainTestCase {
 
   @Test
-  public void unloadedToolchainContext_load() throws Exception {
+  public void load() throws Exception {
     addToolchain(
         "extra",
         "extra_toolchain_linux",
@@ -48,6 +49,8 @@ public void unloadedToolchainContext_load() throws Exception {
             .setExecutionPlatform(linuxPlatform)
             .setTargetPlatform(linuxPlatform)
             .setRequiredToolchainTypes(ImmutableSet.of(testToolchainType))
+            .setRequestedLabelToToolchainType(
+                ImmutableMap.of(testToolchainTypeLabel, testToolchainType))
             .setToolchainTypeToResolved(
                 ImmutableBiMap.<ToolchainTypeInfo, Label>builder()
                     .put(
@@ -73,7 +76,47 @@ public void unloadedToolchainContext_load() throws Exception {
   }
 
   @Test
-  public void unloadedToolchainContext_load_notToolchain() throws Exception {
+  public void load_aliasedToolchain() throws Exception {
+    scratch.file(
+        "alias/BUILD", "alias(name = 'toolchain', actual = '//extra:extra_toolchain_linux_impl')");
+    addToolchain(
+        "extra",
+        "extra_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+
+    // Create a static UnloadedToolchainContext.
+    UnloadedToolchainContext unloadedToolchainContext =
+        UnloadedToolchainContext.builder()
+            .setExecutionPlatform(linuxPlatform)
+            .setTargetPlatform(linuxPlatform)
+            .setRequiredToolchainTypes(ImmutableSet.of(testToolchainType))
+            .setRequestedLabelToToolchainType(
+                ImmutableMap.of(testToolchainTypeLabel, testToolchainType))
+            .setToolchainTypeToResolved(
+                ImmutableBiMap.<ToolchainTypeInfo, Label>builder()
+                    .put(testToolchainType, Label.parseAbsoluteUnchecked("//alias:toolchain"))
+                    .build())
+            .build();
+
+    // Create the prerequisites.
+    ConfiguredTargetAndData toolchain =
+        getConfiguredTargetAndData(Label.parseAbsoluteUnchecked("//alias:toolchain"), targetConfig);
+
+    // Resolve toolchains.
+    ResolvedToolchainContext toolchainContext =
+        ResolvedToolchainContext.load(
+            unloadedToolchainContext, "test", ImmutableList.of(toolchain));
+    assertThat(toolchainContext).isNotNull();
+    assertThat(toolchainContext.forToolchainType(testToolchainType)).isNotNull();
+    assertThat(toolchainContext.forToolchainType(testToolchainType).hasField("data")).isTrue();
+    assertThat(toolchainContext.forToolchainType(testToolchainType).getValue("data"))
+        .isEqualTo("baz");
+  }
+
+  @Test
+  public void load_notToolchain() throws Exception {
     scratch.file("foo/BUILD", "filegroup(name = 'not_a_toolchain')");
 
     // Create a static UnloadedToolchainContext.
@@ -82,6 +125,8 @@ public void unloadedToolchainContext_load_notToolchain() throws Exception {
             .setExecutionPlatform(linuxPlatform)
             .setTargetPlatform(linuxPlatform)
             .setRequiredToolchainTypes(ImmutableSet.of(testToolchainType))
+            .setRequestedLabelToToolchainType(
+                ImmutableMap.of(testToolchainTypeLabel, testToolchainType))
             .setToolchainTypeToResolved(
                 ImmutableBiMap.<ToolchainTypeInfo, Label>builder()
                     .put(testToolchainType, Label.parseAbsoluteUnchecked("//foo:not_a_toolchain"))
@@ -100,7 +145,7 @@ public void unloadedToolchainContext_load_notToolchain() throws Exception {
   }
 
   @Test
-  public void unloadedToolchainContext_load_withTemplateVariables() throws Exception {
+  public void load_withTemplateVariables() throws Exception {
     // Add new toolchain rule that provides template variables.
     Label variableToolchainTypeLabel =
         Label.parseAbsoluteUnchecked("//variable:variable_toolchain_type");
@@ -131,6 +176,8 @@ public void unloadedToolchainContext_load_withTemplateVariables() throws Excepti
             .setExecutionPlatform(linuxPlatform)
             .setTargetPlatform(linuxPlatform)
             .setRequiredToolchainTypes(ImmutableSet.of(variableToolchainType))
+            .setRequestedLabelToToolchainType(
+                ImmutableMap.of(variableToolchainTypeLabel, variableToolchainType))
             .setToolchainTypeToResolved(
                 ImmutableBiMap.<ToolchainTypeInfo, Label>builder()
                     .put(
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
index 84d8777573c379..86077dddb2674b 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
@@ -22,7 +22,7 @@
 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.ToolchainResolutionFunction.NoMatchingPlatformException;
-import com.google.devtools.build.lib.skyframe.ToolchainResolutionFunction.UnresolvedToolchainsException;
+import com.google.devtools.build.lib.skyframe.ToolchainTypeLookupUtil.InvalidToolchainTypeException;
 import com.google.devtools.build.lib.skyframe.util.SkyframeExecutorTestUtils;
 import com.google.devtools.build.skyframe.EvaluationResult;
 import com.google.devtools.build.skyframe.SkyKey;
@@ -92,6 +92,50 @@ public void resolve() throws Exception {
         .isEqualTo(Label.parseAbsoluteUnchecked("//platforms:linux"));
   }
 
+  @Test
+  public void resolve_toolchainTypeAlias() throws Exception {
+    addToolchain(
+        "extra",
+        "extra_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    rewriteWorkspace(
+        "register_toolchains('//extra:extra_toolchain_linux')",
+        "register_execution_platforms('//platforms:linux')");
+
+    // Set up an alias for the toolchain type.
+    Label aliasedToolchainTypeLabel = makeLabel("//alias:toolchain_type");
+    scratch.file(
+        "alias/BUILD", "alias(name = 'toolchain_type', actual = '//toolchain:test_toolchain')");
+
+    useConfiguration("--platforms=//platforms:linux");
+    UnloadedToolchainContext.Key key =
+        UnloadedToolchainContext.key()
+            .configurationKey(targetConfigKey)
+            .requiredToolchainTypeLabels(aliasedToolchainTypeLabel)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    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_noToolchainType() throws Exception {
     scratch.file("host/BUILD", "platform(name = 'host')");
@@ -163,6 +207,7 @@ public void resolve_noToolchainType_hostNotAvailable() throws Exception {
 
   @Test
   public void resolve_unavailableToolchainType_single() throws Exception {
+    scratch.file("fake/toolchain/BUILD", "");
     useConfiguration("--host_platform=//platforms:linux", "--platforms=//platforms:mac");
     UnloadedToolchainContext.Key key =
         UnloadedToolchainContext.key()
@@ -176,16 +221,17 @@ public void resolve_unavailableToolchainType_single() throws Exception {
     assertThatEvaluationResult(result)
         .hasErrorEntryForKeyThat(key)
         .hasExceptionThat()
-        .isInstanceOf(UnresolvedToolchainsException.class);
+        .isInstanceOf(InvalidToolchainTypeException.class);
     assertThatEvaluationResult(result)
         .hasErrorEntryForKeyThat(key)
         .hasExceptionThat()
         .hasMessageThat()
-        .contains("no matching toolchains found for types //fake/toolchain:type_1");
+        .contains("//fake/toolchain:type_1");
   }
 
   @Test
   public void resolve_unavailableToolchainType_multiple() throws Exception {
+    scratch.file("fake/toolchain/BUILD", "");
     useConfiguration("--host_platform=//platforms:linux", "--platforms=//platforms:mac");
     UnloadedToolchainContext.Key key =
         UnloadedToolchainContext.key()
@@ -201,7 +247,7 @@ public void resolve_unavailableToolchainType_multiple() throws Exception {
     assertThatEvaluationResult(result)
         .hasErrorEntryForKeyThat(key)
         .hasExceptionThat()
-        .isInstanceOf(UnresolvedToolchainsException.class);
+        .isInstanceOf(InvalidToolchainTypeException.class);
     // Only one of the missing types will be reported, so do not check the specific error message.
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtilTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtilTest.java
new file mode 100644
index 00000000000000..6910be84f48abf
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainTypeLookupUtilTest.java
@@ -0,0 +1,225 @@
+// Copyright 2019 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.skyframe;
+
+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.devtools.build.lib.analysis.BlazeDirectories;
+import com.google.devtools.build.lib.analysis.platform.ToolchainTypeInfo;
+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.ToolchainTypeLookupUtil.InvalidToolchainTypeException;
+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.Map;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ToolchainTypeLookupUtil}. */
+@RunWith(JUnit4.class)
+public class ToolchainTypeLookupUtilTest extends ToolchainTestCase {
+
+  /**
+   * An {@link AnalysisMock} that injects {@link GetToolchainTypeInfoFunction} into the Skyframe
+   * executor.
+   */
+  private static final class AnalysisMockWithGetToolchainTypeInfoFunction
+      extends AnalysisMock.Delegate {
+    AnalysisMockWithGetToolchainTypeInfoFunction() {
+      super(AnalysisMock.get());
+    }
+
+    @Override
+    public ImmutableMap<SkyFunctionName, SkyFunction> getSkyFunctions(
+        BlazeDirectories directories) {
+      return ImmutableMap.<SkyFunctionName, SkyFunction>builder()
+          .putAll(super.getSkyFunctions(directories))
+          .put(GET_TOOLCHAIN_TYPE_INFO_FUNCTION, new GetToolchainTypeInfoFunction())
+          .build();
+    }
+  }
+
+  @Override
+  protected AnalysisMock getAnalysisMock() {
+    return new AnalysisMockWithGetToolchainTypeInfoFunction();
+  }
+
+  @Test
+  public void testToolchainTypeLookup() throws Exception {
+    ConfiguredTargetKey testToolchainTypeKey =
+        ConfiguredTargetKey.of(testToolchainTypeLabel, targetConfigKey, false);
+    GetToolchainTypeInfoKey key =
+        GetToolchainTypeInfoKey.create(ImmutableList.of(testToolchainTypeKey));
+
+    EvaluationResult<GetToolchainTypeInfoValue> result = getToolchainTypeInfo(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    assertThatEvaluationResult(result).hasEntryThat(key).isNotNull();
+
+    Map<Label, ToolchainTypeInfo> toolchainTypes = result.get(key).toolchainTypes();
+    assertThat(toolchainTypes)
+        .containsExactlyEntriesIn(ImmutableMap.of(testToolchainTypeLabel, testToolchainType));
+  }
+
+  @Test
+  public void testToolchainTypeLookup_toolchainAlias() throws Exception {
+    scratch.file(
+        "alias/BUILD", "alias(name = 'toolchain_type', actual = '" + testToolchainTypeLabel + "')");
+    Label aliasToolchainTypeLabel = makeLabel("//alias:toolchain_type");
+    ConfiguredTargetKey testToolchainTypeKey =
+        ConfiguredTargetKey.of(aliasToolchainTypeLabel, targetConfigKey, false);
+    GetToolchainTypeInfoKey key =
+        GetToolchainTypeInfoKey.create(ImmutableList.of(testToolchainTypeKey));
+
+    EvaluationResult<GetToolchainTypeInfoValue> result = getToolchainTypeInfo(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    assertThatEvaluationResult(result).hasEntryThat(key).isNotNull();
+
+    Map<Label, ToolchainTypeInfo> toolchainTypes = result.get(key).toolchainTypes();
+    assertThat(toolchainTypes)
+        .containsExactlyEntriesIn(
+            ImmutableMap.of(
+                testToolchainTypeLabel,
+                testToolchainType,
+                aliasToolchainTypeLabel,
+                testToolchainType));
+  }
+
+  @Test
+  public void testToolchainTypeLookup_targetNotToolchainType() throws Exception {
+    scratch.file("invalid/BUILD", "filegroup(name = 'not_a_toolchain_type')");
+
+    ConfiguredTargetKey targetKey =
+        ConfiguredTargetKey.of(makeLabel("//invalid:not_a_toolchain_type"), targetConfigKey, false);
+    GetToolchainTypeInfoKey key = GetToolchainTypeInfoKey.create(ImmutableList.of(targetKey));
+
+    EvaluationResult<GetToolchainTypeInfoValue> result = getToolchainTypeInfo(key);
+
+    assertThatEvaluationResult(result).hasError();
+    assertThatEvaluationResult(result)
+        .hasErrorEntryForKeyThat(key)
+        .hasExceptionThat()
+        .isInstanceOf(InvalidToolchainTypeException.class);
+    assertThatEvaluationResult(result)
+        .hasErrorEntryForKeyThat(key)
+        .hasExceptionThat()
+        .hasMessageThat()
+        .contains("//invalid:not_a_toolchain_type");
+  }
+
+  @Test
+  public void testToolchainTypeLookup_targetDoesNotExist() throws Exception {
+    ConfiguredTargetKey targetKey =
+        ConfiguredTargetKey.of(makeLabel("//fake:missing"), targetConfigKey, false);
+    GetToolchainTypeInfoKey key = GetToolchainTypeInfoKey.create(ImmutableList.of(targetKey));
+
+    EvaluationResult<GetToolchainTypeInfoValue> result = getToolchainTypeInfo(key);
+
+    assertThatEvaluationResult(result).hasError();
+    assertThatEvaluationResult(result)
+        .hasErrorEntryForKeyThat(key)
+        .hasExceptionThat()
+        .isInstanceOf(InvalidToolchainTypeException.class);
+    assertThatEvaluationResult(result)
+        .hasErrorEntryForKeyThat(key)
+        .hasExceptionThat()
+        .hasMessageThat()
+        .contains("no such package 'fake': BUILD file not found");
+  }
+
+  // Calls ToolchainTypeLookupUtil.getToolchainTypeInfo.
+  private static final SkyFunctionName GET_TOOLCHAIN_TYPE_INFO_FUNCTION =
+      SkyFunctionName.createHermetic("GET_TOOLCHAIN_TYPE_INFO_FUNCTION");
+
+  @AutoValue
+  abstract static class GetToolchainTypeInfoKey implements SkyKey {
+    @Override
+    public SkyFunctionName functionName() {
+      return GET_TOOLCHAIN_TYPE_INFO_FUNCTION;
+    }
+
+    abstract Iterable<ConfiguredTargetKey> toolchainTypeKeys();
+
+    public static GetToolchainTypeInfoKey create(Iterable<ConfiguredTargetKey> toolchainTypeKeys) {
+      return new AutoValue_ToolchainTypeLookupUtilTest_GetToolchainTypeInfoKey(toolchainTypeKeys);
+    }
+  }
+
+  EvaluationResult<GetToolchainTypeInfoValue> getToolchainTypeInfo(GetToolchainTypeInfoKey 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 GetToolchainTypeInfoValue implements SkyValue {
+    abstract Map<Label, ToolchainTypeInfo> toolchainTypes();
+
+    static GetToolchainTypeInfoValue create(Map<Label, ToolchainTypeInfo> toolchainTypes) {
+      return new AutoValue_ToolchainTypeLookupUtilTest_GetToolchainTypeInfoValue(toolchainTypes);
+    }
+  }
+
+  private static final class GetToolchainTypeInfoFunction implements SkyFunction {
+
+    @Nullable
+    @Override
+    public SkyValue compute(SkyKey skyKey, Environment env)
+        throws SkyFunctionException, InterruptedException {
+      GetToolchainTypeInfoKey key = (GetToolchainTypeInfoKey) skyKey;
+      try {
+        Map<Label, ToolchainTypeInfo> toolchainTypes =
+            ToolchainTypeLookupUtil.resolveToolchainTypes(env, key.toolchainTypeKeys(), false);
+        if (env.valuesMissing()) {
+          return null;
+        }
+        return GetToolchainTypeInfoValue.create(toolchainTypes);
+      } catch (InvalidToolchainTypeException e) {
+        throw new GetToolchainTypeInfoFunctionException(e);
+      }
+    }
+
+    @Nullable
+    @Override
+    public String extractTag(SkyKey skyKey) {
+      return null;
+    }
+  }
+
+  private static class GetToolchainTypeInfoFunctionException extends SkyFunctionException {
+    public GetToolchainTypeInfoFunctionException(InvalidToolchainTypeException e) {
+      super(e, Transience.PERSISTENT);
+    }
+  }
+}
diff --git a/src/test/shell/bazel/toolchain_test.sh b/src/test/shell/bazel/toolchain_test.sh
index 2d91931e1cf7c2..b9953258e9a634 100755
--- a/src/test/shell/bazel/toolchain_test.sh
+++ b/src/test/shell/bazel/toolchain_test.sh
@@ -275,6 +275,100 @@ EOF
   expect_log 'Using toolchain: rule message: "this is the rule", toolchain extra_str: "foo from test_toolchain"'
 }
 
+function test_toolchain_type_alias_use_in_toolchain {
+  write_test_toolchain
+  write_test_rule
+
+  # Create an alias for the toolchain type.
+  mkdir -p alias
+  cat >> alias/BUILD <<EOF
+alias(
+    name = 'toolchain_type',
+    actual = '//toolchain:test_toolchain',
+    visibility = ['//visibility:public'])
+EOF
+
+  # Use the alias.
+  cat >> BUILD <<EOF
+load('//toolchain:toolchain_test_toolchain.bzl', 'test_toolchain')
+
+# Define the toolchain.
+filegroup(name = 'dep_rule_test_toolchain')
+test_toolchain(
+    name = 'test_toolchain_impl_1',
+    extra_label = ':dep_rule_test_toolchain',
+    extra_str = 'foo from test_toolchain',
+    visibility = ['//visibility:public'])
+
+# Declare the toolchain.
+toolchain(
+    name = 'test_toolchain_1',
+    toolchain_type = '//alias:toolchain_type',
+    exec_compatible_with = [],
+    target_compatible_with = [],
+    toolchain = ':test_toolchain_impl_1',
+    visibility = ['//visibility:public'])
+EOF
+
+  # The rule uses the original, non-aliased type.
+  mkdir -p demo
+  cat >> demo/BUILD <<EOF
+load('//toolchain:rule_use_toolchain.bzl', 'use_toolchain')
+# Use the toolchain.
+use_toolchain(
+    name = 'use',
+    message = 'this is the rule')
+EOF
+
+  bazel build --extra_toolchains=//:test_toolchain_1 //demo:use &> $TEST_log || fail "Build failed"
+  expect_log 'Using toolchain: rule message: "this is the rule", toolchain extra_str: "foo from test_toolchain"'
+}
+
+function test_toolchain_type_alias_use_in_rule {
+  write_test_toolchain
+  write_register_toolchain
+
+  # Create an alias for the toolchain type.
+  mkdir -p alias
+  cat >> alias/BUILD <<EOF
+alias(
+    name = 'toolchain_type',
+    actual = '//toolchain:test_toolchain',
+    visibility = ['//visibility:public'])
+EOF
+
+  # Use the alias in a rule.
+  mkdir -p demo
+  cat >> demo/aliased_rule.bzl <<EOF
+def _impl(ctx):
+  toolchain = ctx.toolchains['//alias:toolchain_type']
+  message = ctx.attr.message
+  print(
+      'Using toolchain: rule message: "%s", toolchain extra_str: "%s"' %
+         (message, toolchain.extra_str))
+  return []
+
+aliased_rule = rule(
+    implementation = _impl,
+    attrs = {
+        'message': attr.string(),
+    },
+    toolchains = ['//alias:toolchain_type'],
+)
+EOF
+
+  cat >> demo/BUILD <<EOF
+load(':aliased_rule.bzl', 'aliased_rule')
+# Use the toolchain.
+aliased_rule(
+    name = 'use',
+    message = 'this is the rule')
+EOF
+
+  bazel build //demo:use &> $TEST_log || fail "Build failed"
+  expect_log 'Using toolchain: rule message: "this is the rule", toolchain extra_str: "foo from test_toolchain"'
+}
+
 function test_toolchain_use_in_rule_missing {
   write_test_toolchain
   write_test_rule