diff --git a/src/main/java/com/google/devtools/build/lib/analysis/config/ConfigurationResolver.java b/src/main/java/com/google/devtools/build/lib/analysis/config/ConfigurationResolver.java
index bd2876e..fd6e131 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/config/ConfigurationResolver.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/config/ConfigurationResolver.java
@@ -534,16 +534,22 @@
       Map<PackageValue.Key, PackageValue> buildSettingPackages,
       ExtendedEventHandler eventHandler)
       throws TransitionException {
-    BuildOptions fromOptionsWithDefaults =
-        addDefaultStarlarkOptions(
-            fromOptions,
-            StarlarkTransition.getDefaultInputValues(buildSettingPackages, transition));
+    boolean doesStarlarkTransition = StarlarkTransition.doesStarlarkTransition(transition);
+    if (doesStarlarkTransition) {
+      fromOptions =
+          addDefaultStarlarkOptions(
+              fromOptions,
+              StarlarkTransition.getDefaultInputValues(buildSettingPackages, transition));
+    }
 
     // TODO(bazel-team): safety-check that this never mutates fromOptions.
-    List<BuildOptions> result = transition.apply(fromOptionsWithDefaults);
+    List<BuildOptions> result = transition.apply(fromOptions);
 
-    StarlarkTransition.replayEvents(eventHandler, transition);
-    return StarlarkTransition.validate(transition, buildSettingPackages, result);
+    if (doesStarlarkTransition) {
+      StarlarkTransition.replayEvents(eventHandler, transition);
+      result = StarlarkTransition.validate(transition, buildSettingPackages, result);
+    }
+    return result;
   }
 
   private static BuildOptions addDefaultStarlarkOptions(
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/config/CoreOptions.java b/src/main/java/com/google/devtools/build/lib/analysis/config/CoreOptions.java
index 9497e68..b236f92 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/config/CoreOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/config/CoreOptions.java
@@ -21,6 +21,7 @@
 import com.google.devtools.build.lib.analysis.config.CoreOptionConverters.LabelListConverter;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.util.RegexFilter;
+import com.google.devtools.common.options.Converter;
 import com.google.devtools.common.options.Converters;
 import com.google.devtools.common.options.EnumConverter;
 import com.google.devtools.common.options.Option;
@@ -29,6 +30,7 @@
 import com.google.devtools.common.options.OptionEffectTag;
 import com.google.devtools.common.options.OptionMetadataTag;
 import com.google.devtools.common.options.OptionsParser;
+import com.google.devtools.common.options.OptionsParsingException;
 import com.google.devtools.common.options.TriState;
 import java.util.AbstractMap.SimpleEntry;
 import java.util.LinkedHashMap;
@@ -251,7 +253,7 @@
   public String outputDirectoryName;
 
   /**
-   * This option is used by skylark transitions to add a disginguishing element to the output
+   * This option is used by starlark transitions to add a distinguishing element to the output
    * directory name, in order to avoid name clashing.
    */
   @Option(
@@ -266,6 +268,38 @@
       metadataTags = {OptionMetadataTag.INTERNAL})
   public String transitionDirectoryNameFragment;
 
+  /** Regardless of input, converts to an empty list. For use with affectedByStarlarkTransition */
+  public static class EmptyListConverter implements Converter<List<String>> {
+    @Override
+    public List<String> convert(String input) throws OptionsParsingException {
+      return ImmutableList.of();
+    }
+
+    @Override
+    public String getTypeDescription() {
+      return "Regardless of input, converts to an empty list. For use with"
+          + " affectedByStarlarkTransition";
+    }
+  }
+
+  /**
+   * This internal option is a *set* of names (e.g. "cpu") of *native* options that have been
+   * changed by starlark transitions at any point in the build at the time of accessing. This is
+   * used to regenerate {@code transitionDirectoryNameFragment} after each starlark transition.
+   */
+  @Option(
+      name = "affected by starlark transition",
+      defaultValue = "",
+      converter = EmptyListConverter.class,
+      documentationCategory = OptionDocumentationCategory.UNDOCUMENTED,
+      effectTags = {
+        OptionEffectTag.LOSES_INCREMENTAL_STATE,
+        OptionEffectTag.AFFECTS_OUTPUTS,
+        OptionEffectTag.LOADING_AND_ANALYSIS
+      },
+      metadataTags = {OptionMetadataTag.INTERNAL})
+  public List<String> affectedByStarlarkTransition;
+
   @Option(
       name = "platform_suffix",
       defaultValue = "null",
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/skylark/FunctionTransitionUtil.java b/src/main/java/com/google/devtools/build/lib/analysis/skylark/FunctionTransitionUtil.java
index a3b6b19..161af39 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/skylark/FunctionTransitionUtil.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/skylark/FunctionTransitionUtil.java
@@ -14,14 +14,11 @@
 
 package com.google.devtools.build.lib.analysis.skylark;
 
-import static java.nio.charset.StandardCharsets.US_ASCII;
-
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
-import com.google.common.io.BaseEncoding;
 import com.google.devtools.build.lib.analysis.config.BuildOptions;
 import com.google.devtools.build.lib.analysis.config.CoreOptions;
 import com.google.devtools.build.lib.analysis.config.FragmentOptions;
@@ -33,15 +30,18 @@
 import com.google.devtools.build.lib.syntax.Runtime;
 import com.google.devtools.build.lib.syntax.Runtime.NoneType;
 import com.google.devtools.build.lib.syntax.SkylarkDict;
+import com.google.devtools.build.lib.util.Fingerprint;
 import com.google.devtools.common.options.OptionDefinition;
 import com.google.devtools.common.options.OptionsParser;
 import com.google.devtools.common.options.OptionsParsingException;
 import java.lang.reflect.Field;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
 
 /**
  * Utility class for common work done across {@link StarlarkAttributeTransitionProvider} and {@link
@@ -50,7 +50,6 @@
 public class FunctionTransitionUtil {
 
   public static final String COMMAND_LINE_OPTION_PREFIX = "//command_line_option:";
-
   /**
    * Figure out what build settings the given transition changes and apply those changes to the
    * incoming {@link BuildOptions}. For native options, this involves a preprocess step of
@@ -210,8 +209,8 @@
    * @param buildOptionsToTransition the pre-transition build options
    * @param newValues a map of option name: option value entries to override current option values
    *     in the buildOptions param
-   * @param optionInfoMap a map of option name: option info for all native options that may be
-   *     accessed in this transition
+   * @param optionInfoMap a map of all native options (name -> OptionInfo) present in {@code
+   *     toOptions}.
    * @param starlarkTransition transition object that is being applied. Used for error reporting and
    *     checking for analysis testing
    * @return the post-transition build options
@@ -224,6 +223,7 @@
       StarlarkDefinedConfigTransition starlarkTransition)
       throws EvalException {
     BuildOptions buildOptions = buildOptionsToTransition.clone();
+    HashMap<String, Object> convertedNewValues = new HashMap<>();
     for (Map.Entry<String, Object> entry : newValues.entrySet()) {
       String optionName = entry.getKey();
       Object optionValue = entry.getValue();
@@ -234,6 +234,7 @@
                 .merge(buildOptions)
                 .addStarlarkOption(Label.parseAbsoluteUnchecked(optionName), optionValue)
                 .build();
+        convertedNewValues.put(optionName, optionValue);
       } else {
         optionName = optionName.substring(COMMAND_LINE_OPTION_PREFIX.length());
 
@@ -256,8 +257,11 @@
           FragmentOptions options = buildOptions.get(optionInfo.getOptionClass());
           if (optionValue == null || def.getType().isInstance(optionValue)) {
             field.set(options, optionValue);
+            convertedNewValues.put(entry.getKey(), optionValue);
           } else if (optionValue instanceof String) {
-            field.set(options, def.getConverter().convert((String) optionValue));
+            Object convertedValue = def.getConverter().convert((String) optionValue);
+            field.set(options, convertedValue);
+            convertedNewValues.put(entry.getKey(), convertedValue);
           } else {
             throw new EvalException(
                 starlarkTransition.getLocationForErrorReporting(),
@@ -284,43 +288,70 @@
     if (starlarkTransition.isForAnalysisTesting()) {
       buildConfigOptions.evaluatingForAnalysisTest = true;
     }
-    updateOutputDirectoryNameFragment(buildConfigOptions, newValues);
+    updateOutputDirectoryNameFragment(convertedNewValues.keySet(), optionInfoMap, buildOptions);
 
     return buildOptions;
   }
 
   /**
-   * Compute the output directory name fragment corresponding to the transition, and append it to
-   * the existing name fragment in buildConfigOptions.
+   * Compute the output directory name fragment corresponding to the new BuildOptions based on (1)
+   * the names and values of all native options previously transitioned anywhere in the build by
+   * starlark options, (2) names and values of all entries in the starlark options map.
    *
-   * @throws IllegalStateException If MD5 support is not available
+   * @param changedOptions the names of all options changed by this transition in label form e.g.
+   *     "//command_line_option:cpu" for native options and "//myapp:foo" for starlark options.
+   * @param optionInfoMap a map of all native options (name -> OptionInfo) present in {@code
+   *     toOptions}.
+   * @param toOptions the newly transitioned {@link BuildOptions} for which we need to updated
+   *     {@code transitionDirectoryNameFragment} and {@code affectedByStarlarkTransition}.
    */
+  // TODO(bazel-team): This hashes different forms of equivalent values differently though they
+  // should be the same configuration. Starlark transitions are flexible about the values they
+  // take (e.g. bool-typed options can take 0/1, True/False, "0"/"1", or "True"/"False") which
+  // makes it so that two configurations that are the same in value may hash differently.
   private static void updateOutputDirectoryNameFragment(
-      CoreOptions buildConfigOptions, Map<String, Object> transition) {
-    String transitionString = "";
-    for (Map.Entry<String, Object> entry : transition.entrySet()) {
-      transitionString += entry.getKey() + ":";
-      if (entry.getValue() != null) {
-        transitionString += entry.getValue() + "@";
+      Set<String> changedOptions, Map<String, OptionInfo> optionInfoMap, BuildOptions toOptions) {
+    CoreOptions buildConfigOptions = toOptions.get(CoreOptions.class);
+    Set<String> updatedAffectedByStarlarkTransition =
+        new TreeSet<>(buildConfigOptions.affectedByStarlarkTransition);
+    // Add newly changed native options to overall list of changed native options
+    for (String option : changedOptions) {
+      if (option.startsWith(COMMAND_LINE_OPTION_PREFIX)) {
+        updatedAffectedByStarlarkTransition.add(
+            option.substring(COMMAND_LINE_OPTION_PREFIX.length()));
       }
     }
+    buildConfigOptions.affectedByStarlarkTransition =
+        ImmutableList.sortedCopyOf(updatedAffectedByStarlarkTransition);
 
-    // TODO(waltl): for transitions that don't read settings, it is possible to precompute and
-    // reuse the MD5 digest and even the transition itself.
-    try {
-      byte[] bytes = transitionString.getBytes(US_ASCII);
-      MessageDigest md = MessageDigest.getInstance("MD5");
-      byte[] digest = md.digest(bytes);
-      String hexDigest = BaseEncoding.base16().lowerCase().encode(digest);
-
-      if (buildConfigOptions.transitionDirectoryNameFragment == null) {
-        buildConfigOptions.transitionDirectoryNameFragment = hexDigest;
-      } else {
-        buildConfigOptions.transitionDirectoryNameFragment += "-" + hexDigest;
+    // hash all relevant native option values;
+    TreeMap<String, Object> toHash = new TreeMap<>();
+    for (String nativeOption : updatedAffectedByStarlarkTransition) {
+      Object value;
+      try {
+        value =
+            optionInfoMap
+                .get(nativeOption)
+                .getDefinition()
+                .getField()
+                .get(toOptions.get(optionInfoMap.get(nativeOption).getOptionClass()));
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(
+            "IllegalAccess for option " + nativeOption + ": " + e.getMessage());
       }
-    } catch (NoSuchAlgorithmException e) {
-      throw new IllegalStateException("MD5 not available", e);
+      toHash.put(nativeOption, value);
     }
+
+    // hash all starlark options in map.
+    toOptions.getStarlarkOptions().forEach((opt, value) -> toHash.put(opt.toString(), value));
+
+    Fingerprint fp = new Fingerprint();
+    for (Map.Entry<String, Object> singleOptionAndValue : toHash.entrySet()) {
+      String toAdd = singleOptionAndValue.getKey() + "=" + singleOptionAndValue.getValue();
+      fp.addString(toAdd);
+    }
+    // Make this hash somewhat recognizable
+    buildConfigOptions.transitionDirectoryNameFragment = "ST-" + fp.hexDigestAndReset();
   }
 
   /** Stores option info useful to a FunctionSplitTransition. */
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkTransition.java b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkTransition.java
index f7e6505..2d1472a 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkTransition.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkTransition.java
@@ -46,6 +46,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 
@@ -542,6 +543,18 @@
     return Objects.hashCode(starlarkDefinedConfigTransition);
   }
 
+  /** Given a transition, figures out if it composes any Starlark transitions. */
+  public static boolean doesStarlarkTransition(ConfigurationTransition root)
+      throws TransitionException {
+    AtomicBoolean doesStarlarkTransition = new AtomicBoolean(false);
+    root.visit(
+        (StarlarkTransitionVisitor)
+            transition -> {
+              doesStarlarkTransition.set(true);
+            });
+    return doesStarlarkTransition.get();
+  }
+
   @FunctionalInterface
   // This is only used in this class to handle the cast and the exception
   @SuppressWarnings("FunctionalInterfaceMethodChanged")
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
index 55b5464..6f2d15e 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
@@ -20,6 +20,9 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Maps;
+import com.google.devtools.build.lib.analysis.StarlarkRuleTransitionProviderTest.DummyTestLoader;
+import com.google.devtools.build.lib.analysis.config.CoreOptions;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.packages.Provider;
@@ -27,6 +30,8 @@
 import com.google.devtools.build.lib.packages.SkylarkProvider;
 import com.google.devtools.build.lib.packages.StructImpl;
 import com.google.devtools.build.lib.packages.util.BazelMockAndroidSupport;
+import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
+import com.google.devtools.build.lib.util.Fingerprint;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.junit.Before;
@@ -38,6 +43,14 @@
 @RunWith(JUnit4.class)
 public class StarlarkAttrTransitionProviderTest extends BuildViewTestCase {
 
+  @Override
+  protected ConfiguredRuleClassProvider getRuleClassProvider() {
+    ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder();
+    TestRuleClassProvider.addStandardRules(builder);
+    builder.addConfigurationFragment(new DummyTestLoader());
+    return builder.build();
+  }
+
   @Before
   public void setupMyInfo() throws Exception {
     scratch.file("myinfo/myinfo.bzl", "MyInfo = provider()");
@@ -58,7 +71,7 @@
         "package_group(",
         "    name = 'function_transition_whitelist',",
         "    packages = [",
-        "        '//test/skylark/...',",
+        "        '//test/...',",
         "    ],",
         ")");
   }
@@ -209,7 +222,7 @@
     writeWhitelistFile();
     getAnalysisMock().ccSupport().setupCcToolchainConfigForCpu(mockToolsConfig, "armeabi-v7a");
     scratch.file(
-        "test/not_whitelisted/my_rule.bzl",
+        "not_whitelisted/my_rule.bzl",
         "load('//myinfo:myinfo.bzl', 'MyInfo')",
         "def transition_func(settings, attr):",
         "  return [",
@@ -232,13 +245,13 @@
         "    ),",
         "  })");
     scratch.file(
-        "test/not_whitelisted/BUILD",
-        "load('//test/not_whitelisted:my_rule.bzl', 'my_rule')",
+        "not_whitelisted/BUILD",
+        "load('//not_whitelisted:my_rule.bzl', 'my_rule')",
         "my_rule(name = 'test', dep = ':main')",
         "cc_binary(name = 'main', srcs = ['main.c'])");
 
     reporter.removeHandler(failFastHandler);
-    getConfiguredTarget("//test/not_whitelisted:test");
+    getConfiguredTarget("//not_whitelisted:test");
     assertContainsEvent("Non-whitelisted use of Starlark transition");
   }
 
@@ -523,7 +536,7 @@
         "def transition_func(settings, attr):",
         "  return {'//command_line_option:cpu': 'k8'}",
         "my_transition = transition(implementation = transition_func,",
-        "  inputs = ['//command_line_option:foo', '//command_line_option:bar'],",
+        "  inputs = ['//command_line_option:foop', '//command_line_option:barp'],",
         "  outputs = ['//command_line_option:cpu'])",
         "def impl(ctx): ",
         "  return []",
@@ -545,7 +558,7 @@
     reporter.removeHandler(failFastHandler);
     getConfiguredTarget("//test/skylark:test");
     assertContainsEvent(
-        "transition inputs [//command_line_option:foo, //command_line_option:bar] "
+        "transition inputs [//command_line_option:foop, //command_line_option:barp] "
             + "do not correspond to valid settings");
   }
 
@@ -860,6 +873,635 @@
         .isEqualTo(42);
   }
 
+  private CoreOptions getCoreOptions(ConfiguredTarget target) {
+    return getConfiguration(target).getOptions().get(CoreOptions.class);
+  }
+
+  @Test
+  public void testOutputDirHash_multipleNativeOptionTransitions() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_impl(settings, attr):",
+        "  return {'//command_line_option:foo': 'foosball'}",
+        "foo_transition = transition(implementation = _foo_impl, inputs = [],",
+        "  outputs = ['//command_line_option:foo'])",
+        "def _bar_impl(settings, attr):",
+        "  return {'//command_line_option:bar': 'barsball'}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = ['//command_line_option:bar'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'foo_transition', 'bar_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = foo_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bar_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    List<String> affectedOptions = getCoreOptions(test).affectedByStarlarkTransition;
+
+    assertThat(affectedOptions).containsExactly("foo");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    affectedOptions = getCoreOptions(dep).affectedByStarlarkTransition;
+
+    assertThat(affectedOptions).containsExactly("foo", "bar");
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo("ST-" + new Fingerprint().addString("foo=foosball").hexDigestAndReset());
+
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment)
+        .isEqualTo(
+            "ST-"
+                + new Fingerprint()
+                    .addString("bar=barsball")
+                    .addString("foo=foosball")
+                    .hexDigestAndReset());
+  }
+
+  // Test that a no-op starlark transition to an already starlark transitioned configuration
+  // results in the same configuration.
+  @Test
+  public void testOutputDirHash_noop_changeToSameState() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _bar_impl(settings, attr):",
+        "  return {'//test:bar': 'barsball'}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = ['//test:bar'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'bar_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = bar_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bar_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'string_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "string_flag(name = 'bar', build_setting_default = '')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo(getCoreOptions(dep).transitionDirectoryNameFragment);
+  }
+
+  @Test
+  public void testOutputDirHash_noop_emptyReturns() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _bar_impl(settings, attr):",
+        "  return {}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = [])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'bar_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = bar_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bar_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo(getCoreOptions(dep).transitionDirectoryNameFragment);
+  }
+
+  // Test that a no-op starlark transition to the top level configuration results in a
+  // different configuration.
+  // TODO(bazel-team): This can be optimized. Make these the same configuration.
+  @Test
+  public void testOutputDirHash_noop_changeToDifferentStateAsTopLevel() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _bar_impl(settings, attr):",
+        "  return {'//test:bar': 'barsball'}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = ['//test:bar'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'bar_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bar_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'string_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "string_flag(name = 'bar', build_setting_default = '')");
+
+    // Use configuration that is same as what the transition will change.
+    useConfiguration(ImmutableMap.of("//test:bar", "barsball"));
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment).isNull();
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment).isNotNull();
+  }
+
+  // Test that setting all starlark options back to default != null hash of top level.
+  // We could set some starlark options on the command line but we don't count this as a starlark
+  // transition to the command line configuration will always have a null values for
+  // {@code transitionDirectoryNameFragment}.
+  //
+  // e.g. for a build setting //foo whose default value is "foop" the following sequence
+  //
+  // (CommandLine) //foo=blah -> (StarlarkTransition) //foo=foop
+  //
+  // must create a non-null hash for after the StarlarkTransition even though later on we empty
+  // the default out of the starlark map (In StarlarkTransition#validate)
+  // TODO(bazel-team): This can be optimized. Make these the same configuration.
+  @Test
+  public void testOutputDirHash_multipleStarlarkOptionTransitions_backToDefaultCommandLine()
+      throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_two_impl(settings, attr):",
+        "  return {'//test:foo': 'foosballerina'}",
+        "foo_two_transition = transition(implementation = _foo_two_impl, inputs = [],",
+        "  outputs = ['//test:foo'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'foo_two_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = foo_two_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'string_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "string_flag(name = 'foo', build_setting_default = 'foosballerina')");
+
+    useConfiguration(ImmutableMap.of("//test:foo", "foosball"));
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>)
+                getMyInfoFromTarget(getConfiguredTarget("//test")).getValue("dep"));
+
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment).isNotNull();
+  }
+
+  // Test that setting a starlark option to default (if it was already at default) doesn't
+  // produce the same hash. This is because we do hashing  before scrubbing default values
+  // out of {@code BuildOptions}.
+  // TODO(bazel-team): This can be optimized. Make these the same configuration.
+  @Test
+  public void testOutputDirHash_multipleStarlarkOptionTransitions_backToDefault() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_two_impl(settings, attr):",
+        "  return {'//test:foo': 'foosballerina'}",
+        "foo_two_transition = transition(implementation = _foo_two_impl, inputs = [],",
+        "  outputs = ['//test:foo'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'foo_two_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = foo_two_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'string_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "string_flag(name = 'foo', build_setting_default = 'foosballerina')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment)
+        .isNotEqualTo(getCoreOptions(test).transitionDirectoryNameFragment);
+  }
+
+  /** See comment above {@link FunctionTransitionUtil#updateOutputDirectoryNameFragment} */
+  // TODO(bazel-team): This can be optimized. Make these the same configuration.
+  @Test
+  public void testOutputDirHash_starlarkOption_differentBoolRepresentationsNotEquals()
+      throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_impl(settings, attr):",
+        "  return {'//test:foo': 1}",
+        "foo_transition = transition(implementation = _foo_impl, inputs = [],",
+        "  outputs = ['//test:foo'])",
+        "def _foo_two_impl(settings, attr):",
+        "  return {'//test:foo': True}",
+        "foo_two_transition = transition(implementation = _foo_two_impl, inputs = [],",
+        "  outputs = ['//test:foo'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'foo_transition', 'foo_two_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = foo_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = foo_two_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "bool_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.bool(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'bool_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "bool_flag(name = 'foo', build_setting_default = False)");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo("ST-" + new Fingerprint().addString("//test:foo=1").hexDigestAndReset());
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment)
+        .isEqualTo("ST-" + new Fingerprint().addString("//test:foo=true").hexDigestAndReset());
+  }
+
+  @Test
+  public void testOutputDirHash_nativeOption_differentBoolRepresentationsEquals() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _bool_impl(settings, attr):",
+        "  return {'//command_line_option:bool': '1'}",
+        "bool_transition = transition(implementation = _bool_impl, inputs = [],",
+        "  outputs = ['//command_line_option:bool'])",
+        "def _bool_two_impl(settings, attr):",
+        "  return {'//command_line_option:bool': 'true'}",
+        "bool_two_transition = transition(implementation = _bool_two_impl, inputs = [],",
+        "  outputs = ['//command_line_option:bool'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'bool_transition', 'bool_two_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = bool_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bool_two_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo(getCoreOptions(dep).transitionDirectoryNameFragment);
+  }
+
+  @Test
+  public void testOutputDirHash_multipleStarlarkTransitions() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_impl(settings, attr):",
+        "  return {'//test:foo': 'foosball'}",
+        "foo_transition = transition(implementation = _foo_impl, inputs = [],",
+        "  outputs = ['//test:foo'])",
+        "def _bar_impl(settings, attr):",
+        "  return {'//test:bar': 'barsball'}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = ['//test:bar'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load('//test:transitions.bzl', 'foo_transition', 'bar_transition')",
+        "def _impl(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        "  cfg = foo_transition,",
+        "  attrs = {",
+        "    'dep': attr.label(cfg = bar_transition), ",
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule', 'string_flag', 'simple')",
+        "my_rule(name = 'test', dep = ':dep')",
+        "simple(name = 'dep')",
+        "string_flag(name = 'foo', build_setting_default = '')",
+        "string_flag(name = 'bar', build_setting_default = '')");
+
+    ConfiguredTarget test = getConfiguredTarget("//test");
+
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget dep =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(test).getValue("dep"));
+
+    List<String> affectedOptions =
+        getConfiguration(dep).getOptions().get(CoreOptions.class).affectedByStarlarkTransition;
+
+    // Assert that affectedOptions is empty but final fragment is still different.
+    assertThat(affectedOptions).isEmpty();
+    assertThat(getCoreOptions(test).transitionDirectoryNameFragment)
+        .isEqualTo("ST-" + new Fingerprint().addString("//test:foo=foosball").hexDigestAndReset());
+    assertThat(getCoreOptions(dep).transitionDirectoryNameFragment)
+        .isEqualTo(
+            "ST-"
+                + new Fingerprint()
+                    .addString("//test:bar=barsball")
+                    .addString("//test:foo=foosball")
+                    .hexDigestAndReset());
+  }
+
+  // This test is massive but mostly exists to ensure that all the parts are working together
+  // properly amidst multiple complicated transitions.
+  @Test
+  public void testOutputDirHash_multipleMixedTransitions() throws Exception {
+    writeWhitelistFile();
+    scratch.file(
+        "test/transitions.bzl",
+        "def _foo_impl(settings, attr):",
+        "  return {'//command_line_option:foo': 'foosball'}",
+        "foo_transition = transition(implementation = _foo_impl, inputs = [],",
+        "  outputs = ['//command_line_option:foo'])",
+        "def _bar_impl(settings, attr):",
+        "  return {'//command_line_option:bar': 'barsball'}",
+        "bar_transition = transition(implementation = _bar_impl, inputs = [],",
+        "  outputs = ['//command_line_option:bar'])",
+        "def _zee_impl(settings, attr):",
+        "  return {'//test:zee': 'zeesball'}",
+        "zee_transition = transition(implementation = _zee_impl, inputs = [],",
+        "  outputs = ['//test:zee'])",
+        "def _xan_impl(settings, attr):",
+        "  return {'//test:xan': 'xansball'}",
+        "xan_transition = transition(implementation = _xan_impl, inputs = [],",
+        "  outputs = ['//test:xan'])");
+    scratch.file(
+        "test/rules.bzl",
+        "load('//myinfo:myinfo.bzl', 'MyInfo')",
+        "load(",
+        "  '//test:transitions.bzl',",
+        "  'foo_transition',",
+        "  'bar_transition',",
+        "  'zee_transition',",
+        "  'xan_transition')",
+        "def _impl_a(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule_a = rule(",
+        "  implementation = _impl_a,",
+        "  cfg = foo_transition,", // transition #1
+        "  attrs = {",
+        "    'dep': attr.label(cfg = zee_transition), ", // transition #2
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _impl_b(ctx):",
+        "  return MyInfo(dep = ctx.attr.dep)",
+        "my_rule_b = rule(",
+        "  implementation = _impl_b,",
+        "  cfg = bar_transition,", // transition #3
+        "  attrs = {",
+        "    'dep': attr.label(cfg = xan_transition), ", // transition #4
+        "    '_whitelist_function_transition': attr.label(",
+        "        default = '//tools/whitelists/function_transition_whitelist',",
+        "    ),",
+        "  })",
+        "def _basic_impl(ctx):",
+        "  return []",
+        "string_flag = rule(",
+        "  implementation = _basic_impl,",
+        "  build_setting = config.string(flag = True),",
+        ")",
+        "simple = rule(_basic_impl)");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:rules.bzl', 'my_rule_a', 'my_rule_b', 'string_flag', 'simple')",
+        "my_rule_a(name = 'top', dep = ':middle')",
+        "my_rule_b(name = 'middle', dep = 'bottom')",
+        "simple(name = 'bottom')",
+        "string_flag(name = 'zee', build_setting_default = '')",
+        "string_flag(name = 'xan', build_setting_default = '')");
+
+    // test:top (foo_transition)
+    ConfiguredTarget top = getConfiguredTarget("//test:top");
+
+    List<String> affectedOptionsTop =
+        getConfiguration(top).getOptions().get(CoreOptions.class).affectedByStarlarkTransition;
+
+    assertThat(affectedOptionsTop).containsExactly("foo");
+    assertThat(getConfiguration(top).getOptions().getStarlarkOptions()).isEmpty();
+    assertThat(getCoreOptions(top).transitionDirectoryNameFragment)
+        .isEqualTo("ST-" + new Fingerprint().addString("foo=foosball").hexDigestAndReset());
+
+    // test:middle (foo_transition, zee_transition, bar_transition)
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget middle =
+        Iterables.getOnlyElement((List<ConfiguredTarget>) getMyInfoFromTarget(top).getValue("dep"));
+
+    List<String> affectedOptionsMiddle =
+        getConfiguration(middle).getOptions().get(CoreOptions.class).affectedByStarlarkTransition;
+
+    assertThat(affectedOptionsMiddle).containsExactly("foo", "bar");
+    assertThat(getConfiguration(middle).getOptions().getStarlarkOptions().entrySet())
+        .containsExactly(
+            Maps.immutableEntry(Label.parseAbsoluteUnchecked("//test:zee"), "zeesball"));
+    assertThat(getCoreOptions(middle).transitionDirectoryNameFragment)
+        .isEqualTo(
+            "ST-"
+                + new Fingerprint()
+                    .addString("//test:zee=zeesball")
+                    .addString("bar=barsball")
+                    .addString("foo=foosball")
+                    .hexDigestAndReset());
+
+    // test:bottom (foo_transition, zee_transition, bar_transition, xan_transition)
+    @SuppressWarnings("unchecked")
+    ConfiguredTarget bottom =
+        Iterables.getOnlyElement(
+            (List<ConfiguredTarget>) getMyInfoFromTarget(middle).getValue("dep"));
+
+    List<String> affectedOptionsBottom =
+        getConfiguration(bottom).getOptions().get(CoreOptions.class).affectedByStarlarkTransition;
+
+    assertThat(affectedOptionsBottom).containsExactly("foo", "bar");
+    assertThat(getConfiguration(bottom).getOptions().getStarlarkOptions().entrySet())
+        .containsExactly(
+            Maps.immutableEntry(Label.parseAbsoluteUnchecked("//test:zee"), "zeesball"),
+            Maps.immutableEntry(Label.parseAbsoluteUnchecked("//test:xan"), "xansball"));
+    assertThat(getCoreOptions(bottom).transitionDirectoryNameFragment)
+        .isEqualTo(
+            "ST-"
+                + new Fingerprint()
+                    .addString("//test:xan=xansball")
+                    .addString("//test:zee=zeesball")
+                    .addString("bar=barsball")
+                    .addString("foo=foosball")
+                    .hexDigestAndReset());
+  }
+
   @Test
   public void testTransitionOnBuildSetting_badValue() throws Exception {
     setSkylarkSemanticsOptions(
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkRuleTransitionProviderTest.java b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkRuleTransitionProviderTest.java
index 2670404..95e7f02 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkRuleTransitionProviderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkRuleTransitionProviderTest.java
@@ -54,10 +54,34 @@
         effectTags = {OptionEffectTag.NO_OP},
         help = "An option that is sometimes set to null.")
     public Label nullable;
+
+    @Option(
+        name = "foo",
+        defaultValue = "",
+        documentationCategory = OptionDocumentationCategory.UNDOCUMENTED,
+        effectTags = {OptionEffectTag.NO_OP},
+        help = "A regular string-typed option")
+    public String foo;
+
+    @Option(
+        name = "bar",
+        defaultValue = "",
+        documentationCategory = OptionDocumentationCategory.UNDOCUMENTED,
+        effectTags = {OptionEffectTag.NO_OP},
+        help = "A regular string-typed option")
+    public String bar;
+
+    @Option(
+        name = "bool",
+        defaultValue = "false",
+        documentationCategory = OptionDocumentationCategory.UNDOCUMENTED,
+        effectTags = {OptionEffectTag.NO_OP},
+        help = "A regular bool-typed option")
+    public boolean bool;
   }
 
   /** Loads a new {link @DummyTestFragment} instance. */
-  private static class DummyTestLoader implements ConfigurationFragmentFactory {
+  protected static class DummyTestLoader implements ConfigurationFragmentFactory {
 
     @Override
     public Fragment create(BuildOptions buildOptions) throws InvalidConfigurationException {
diff --git a/src/test/shell/integration/starlark_configurations_test.sh b/src/test/shell/integration/starlark_configurations_test.sh
index 48c8813..a8697d4 100755
--- a/src/test/shell/integration/starlark_configurations_test.sh
+++ b/src/test/shell/integration/starlark_configurations_test.sh
@@ -454,4 +454,72 @@
   expect_log "value=command_line_val"
 }
 
+function test_output_same_config_as_generating_target() {
+  local -r pkg=$FUNCNAME
+  mkdir -p $pkg
+
+  rm -rf tools/whitelists/function_transition_whitelist
+  mkdir -p tools/whitelists/function_transition_whitelist
+  cat > tools/whitelists/function_transition_whitelist/BUILD <<EOF
+package_group(
+    name = "function_transition_whitelist",
+    packages = [
+        "//...",
+    ],
+)
+EOF
+
+  cat > $pkg/rules.bzl <<EOF
+def _rule_class_transition_impl(settings, attr):
+    return {
+        "//command_line_option:test_arg": ["blah"]
+    }
+
+_rule_class_transition = transition(
+    implementation = _rule_class_transition_impl,
+    inputs = [],
+    outputs = [
+        "//command_line_option:test_arg",
+    ],
+)
+
+def _rule_class_transition_rule_impl(ctx):
+    ctx.actions.write(ctx.outputs.artifact, "hello\n")
+    return [DefaultInfo(files = depset([ctx.outputs.artifact]))]
+
+rule_class_transition_rule = rule(
+    _rule_class_transition_rule_impl,
+    cfg = _rule_class_transition,
+    attrs = {
+        "_whitelist_function_transition": attr.label(default = "//tools/whitelists/function_transition_whitelist"),
+    },
+    outputs = {"artifact": "%{name}.output"},
+)
+EOF
+
+  cat > $pkg/BUILD <<EOF
+load("//$pkg:rules.bzl", "rule_class_transition_rule")
+
+rule_class_transition_rule(name = "with_rule_class_transition")
+EOF
+
+  bazel build //$pkg:with_rule_class_transition.output > output 2>"$TEST_log" || fail "Expected success"
+
+  bazel cquery "deps(//$pkg:with_rule_class_transition.output, 1)" > output 2>"$TEST_log" || fail "Expected success"
+
+  assert_contains "//$pkg:with_rule_class_transition.output " output
+  assert_contains "//$pkg:with_rule_class_transition " output
+
+  # Find the lines of output for the output target and the generating target
+  OUTPUT=$(grep "//$pkg:with_rule_class_transition.output " output)
+  TARGET=$(grep "//$pkg:with_rule_class_transition " output)
+
+  # Trim to just configuration
+  OUTPUT_CONFIG=${OUTPUT/"//$pkg:with_rule_class_transition.output "}
+  TARGET_CONFIG=${TARGET/"//$pkg:with_rule_class_transition "}
+
+  # Confirm same configuration
+  assert_equals $OUTPUT_CONFIG $TARGET_CONFIG
+}
+
 run_suite "${PRODUCT_NAME} starlark configurations tests"