diff --git a/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java b/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
index 63da67c..af957ff 100644
--- a/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
+++ b/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
@@ -36,13 +36,13 @@
   public static final String RULES_TEMPLATE = BE_TEMPLATE_DIR + "/rules.vm";
   public static final String BE_NAV_TEMPLATE = BE_TEMPLATE_DIR + "/be-nav.vm";
 
-  public static final String SKYLARK_LIBRARY_TEMPLATE =
+  public static final String STARLARK_LIBRARY_TEMPLATE =
       "com/google/devtools/build/docgen/templates/skylark-library.vm";
-  public static final String SKYLARK_NAV_TEMPLATE =
+  public static final String STARLARK_NAV_TEMPLATE =
       "com/google/devtools/build/docgen/templates/skylark-nav.vm";
-  public static final String SKYLARK_MODULE_CATEGORY_TEMPLATE =
+  public static final String STARLARK_MODULE_CATEGORY_TEMPLATE =
       "com/google/devtools/build/docgen/templates/skylark-category.vm";
-  public static final String SKYLARK_OVERVIEW_TEMPLATE =
+  public static final String STARLARK_OVERVIEW_TEMPLATE =
       "com/google/devtools/build/docgen/templates/skylark-overview.vm";
 
   public static final String VAR_LEFT_PANEL = "LEFT_PANEL";
@@ -60,7 +60,7 @@
   public static final String VAR_TEST_ATTRIBUTE_DEFINITION = "TEST_ATTRIBUTE_DEFINITION";
   public static final String VAR_BINARY_ATTRIBUTE_DEFINITION = "BINARY_ATTRIBUTE_DEFINITION";
 
-  public static final String VAR_SECTION_SKYLARK_BUILTIN = "SECTION_BUILTIN";
+  public static final String VAR_SECTION_STARLARK_BUILTIN = "SECTION_BUILTIN";
 
   public static final String COMMON_ATTRIBUTES = "common";
   public static final String TEST_ATTRIBUTES = "test";
diff --git a/src/main/java/com/google/devtools/build/docgen/StarlarkDocumentationProcessor.java b/src/main/java/com/google/devtools/build/docgen/StarlarkDocumentationProcessor.java
index d97d949..b46d25d 100644
--- a/src/main/java/com/google/devtools/build/docgen/StarlarkDocumentationProcessor.java
+++ b/src/main/java/com/google/devtools/build/docgen/StarlarkDocumentationProcessor.java
@@ -139,7 +139,7 @@
 
   private static void writePage(String outputDir, StarlarkBuiltinDoc module) throws IOException {
     File skylarkDocPath = new File(outputDir + "/" + module.getName() + ".html");
-    Page page = TemplateEngine.newPage(DocgenConsts.SKYLARK_LIBRARY_TEMPLATE);
+    Page page = TemplateEngine.newPage(DocgenConsts.STARLARK_LIBRARY_TEMPLATE);
     page.add("module", module);
     page.write(skylarkDocPath);
   }
@@ -151,7 +151,7 @@
       throws IOException {
     File skylarkDocPath = new File(String.format("%s/skylark-%s.html",
         outputDir, category.getTemplateIdentifier()));
-    Page page = TemplateEngine.newPage(DocgenConsts.SKYLARK_MODULE_CATEGORY_TEMPLATE);
+    Page page = TemplateEngine.newPage(DocgenConsts.STARLARK_MODULE_CATEGORY_TEMPLATE);
     page.add("category", category);
     page.add("modules", modules.get(category));
     page.add("description", StarlarkDocUtils.substituteVariables(category.getDescription()));
@@ -161,7 +161,7 @@
   private static void writeNavPage(String outputDir, List<StarlarkBuiltinDoc> navModules)
       throws IOException {
     File navFile = new File(outputDir + "/skylark-nav.html");
-    Page page = TemplateEngine.newPage(DocgenConsts.SKYLARK_NAV_TEMPLATE);
+    Page page = TemplateEngine.newPage(DocgenConsts.STARLARK_NAV_TEMPLATE);
     page.add("modules", navModules);
     page.write(navFile);
   }
@@ -175,7 +175,7 @@
       Map<StarlarkDocumentationCategory, List<StarlarkBuiltinDoc>> modulesPerCategory)
       throws IOException {
     File skylarkDocPath = new File(outputDir + "/skylark-overview.html");
-    Page page = TemplateEngine.newPage(DocgenConsts.SKYLARK_OVERVIEW_TEMPLATE);
+    Page page = TemplateEngine.newPage(DocgenConsts.STARLARK_OVERVIEW_TEMPLATE);
     page.add("global_name", globalModuleName);
     page.add("global_functions", globalFunctions);
     page.add("global_constants", globalConstants);
diff --git a/src/main/java/com/google/devtools/build/lib/actions/CommandLineItem.java b/src/main/java/com/google/devtools/build/lib/actions/CommandLineItem.java
index 2861670..e7e9055 100644
--- a/src/main/java/com/google/devtools/build/lib/actions/CommandLineItem.java
+++ b/src/main/java/com/google/devtools/build/lib/actions/CommandLineItem.java
@@ -76,7 +76,7 @@
    */
   static String expandToCommandLine(Object object) {
     // TODO(b/150322434): The fallback on toString() isn't great. Particularly so for
-    // SkylarkCustomCommandLine, since toString() does not necessarily give the same results as
+    // StarlarkCustomCommandLine, since toString() does not necessarily give the same results as
     // Starlark's str() or repr().
     //
     // The ideal refactoring is to make StarlarkValue implement CommandLineItem (or a slimmer
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/AnalysisUtils.java b/src/main/java/com/google/devtools/build/lib/analysis/AnalysisUtils.java
index 78d7c6a..5a03634 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/AnalysisUtils.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/AnalysisUtils.java
@@ -93,10 +93,10 @@
    */
   public static <T extends Info> List<T> getProviders(
       Iterable<? extends TransitiveInfoCollection> prerequisites,
-      final NativeProvider<T> skylarkKey) {
+      final NativeProvider<T> starlarkKey) {
     ImmutableList.Builder<T> result = ImmutableList.builder();
     for (TransitiveInfoCollection prerequisite : prerequisites) {
-      T prerequisiteProvider = prerequisite.get(skylarkKey);
+      T prerequisiteProvider = prerequisite.get(starlarkKey);
       if (prerequisiteProvider != null) {
         result.add(prerequisiteProvider);
       }
@@ -110,10 +110,10 @@
    */
   public static <T extends Info> List<T> getProviders(
       Iterable<? extends TransitiveInfoCollection> prerequisites,
-      final BuiltinProvider<T> skylarkKey) {
+      final BuiltinProvider<T> starlarkKey) {
     ImmutableList.Builder<T> result = ImmutableList.builder();
     for (TransitiveInfoCollection prerequisite : prerequisites) {
-      T prerequisiteProvider = prerequisite.get(skylarkKey);
+      T prerequisiteProvider = prerequisite.get(starlarkKey);
       if (prerequisiteProvider != null) {
         result.add(prerequisiteProvider);
       }
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/BuildView.java b/src/main/java/com/google/devtools/build/lib/analysis/BuildView.java
index 76f5c89..1bde506 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/BuildView.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/BuildView.java
@@ -322,9 +322,9 @@
             bzlFileLoadLikeString = bzlFileLoadLikeString + ".bzl";
           }
         }
-        Label skylarkFileLabel;
+        Label starlarkFileLabel;
         try {
-          skylarkFileLabel =
+          starlarkFileLabel =
               Label.parseAbsolute(
                   bzlFileLoadLikeString, /* repositoryMapping= */ ImmutableMap.of());
         } catch (LabelSyntaxException e) {
@@ -332,7 +332,7 @@
               String.format("Invalid aspect '%s': %s", aspect, e.getMessage()), e);
         }
 
-        String skylarkFunctionName = aspect.substring(delimiterPosition + 1);
+        String starlarkFunctionName = aspect.substring(delimiterPosition + 1);
         for (TargetAndConfiguration targetSpec : topLevelTargetsWithConfigs) {
           if (targetSpec.getConfiguration() != null
               && targetSpec.getConfiguration().trimConfigurationsRetroactively()) {
@@ -348,8 +348,8 @@
                   // aspect and the base target while the top-level configuration is untrimmed.
                   targetSpec.getConfiguration(),
                   targetSpec.getConfiguration(),
-                  skylarkFileLabel,
-                  skylarkFunctionName));
+                  starlarkFileLabel,
+                  starlarkFunctionName));
         }
       } else {
         final NativeAspectClass aspectFactoryClass =
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredAspect.java b/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredAspect.java
index b6bbc08..e508767 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/ConfiguredAspect.java
@@ -98,8 +98,8 @@
 
   @Override
   public Object get(String legacyKey) {
-    if (OutputGroupInfo.SKYLARK_NAME.equals(legacyKey)) {
-      return get(OutputGroupInfo.SKYLARK_CONSTRUCTOR.getKey());
+    if (OutputGroupInfo.STARLARK_NAME.equals(legacyKey)) {
+      return get(OutputGroupInfo.STARLARK_CONSTRUCTOR.getKey());
     }
     return providers.get(legacyKey);
   }
@@ -226,7 +226,7 @@
           outputGroups.put(entry.getKey(), entry.getValue().build());
         }
 
-        if (providers.contains(OutputGroupInfo.SKYLARK_CONSTRUCTOR.getKey())) {
+        if (providers.contains(OutputGroupInfo.STARLARK_CONSTRUCTOR.getKey())) {
           throw new IllegalStateException(
               "OutputGroupInfo was provided explicitly; do not use addOutputGroup");
         }
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/FilesToRunProvider.java b/src/main/java/com/google/devtools/build/lib/analysis/FilesToRunProvider.java
index f75e72a..351511c 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/FilesToRunProvider.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/FilesToRunProvider.java
@@ -31,7 +31,7 @@
 public final class FilesToRunProvider
     implements TransitiveInfoProvider, FilesToRunProviderApi<Artifact> {
   /** The name of the field in Starlark used to access this class. */
-  public static final String SKYLARK_NAME = "files_to_run";
+  public static final String STARLARK_NAME = "files_to_run";
 
   public static final FilesToRunProvider EMPTY =
       new FilesToRunProvider(NestedSetBuilder.<Artifact>emptySet(Order.STABLE_ORDER), null, null);
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/OutputGroupInfo.java b/src/main/java/com/google/devtools/build/lib/analysis/OutputGroupInfo.java
index 6e544d3..f4fa960 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/OutputGroupInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/OutputGroupInfo.java
@@ -61,9 +61,9 @@
 @AutoCodec
 public final class OutputGroupInfo extends StructImpl
     implements StarlarkIndexable, StarlarkIterable<String>, OutputGroupInfoApi {
-  public static final String SKYLARK_NAME = "output_groups";
+  public static final String STARLARK_NAME = "output_groups";
 
-  public static final OutputGroupInfoProvider SKYLARK_CONSTRUCTOR = new OutputGroupInfoProvider();
+  public static final OutputGroupInfoProvider STARLARK_CONSTRUCTOR = new OutputGroupInfoProvider();
 
   /**
    * Prefix for output groups that are not reported to the user on the terminal output of Blaze when
@@ -137,7 +137,7 @@
   private final ImmutableMap<String, NestedSet<Artifact>> outputGroups;
 
   public OutputGroupInfo(ImmutableMap<String, NestedSet<Artifact>> outputGroups) {
-    super(SKYLARK_CONSTRUCTOR, Location.BUILTIN);
+    super(STARLARK_CONSTRUCTOR, Location.BUILTIN);
     this.outputGroups = outputGroups;
   }
 
@@ -148,7 +148,7 @@
 
   @Nullable
   public static OutputGroupInfo get(ProviderCollection collection) {
-    return collection.get(SKYLARK_CONSTRUCTOR);
+    return collection.get(STARLARK_CONSTRUCTOR);
   }
 
   /** Return the artifacts in a particular output group.
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/ProviderCollection.java b/src/main/java/com/google/devtools/build/lib/analysis/ProviderCollection.java
index 0dbf1dc..f941685 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/ProviderCollection.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/ProviderCollection.java
@@ -22,7 +22,7 @@
 import javax.annotation.Nullable;
 
 /**
- * Interface to mark classes that could contain transitive information added using the Skylark
+ * Interface to mark classes that could contain transitive information added using the Starlark
  * framework.
  */
 public interface ProviderCollection {
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/RuleConfiguredTargetBuilder.java b/src/main/java/com/google/devtools/build/lib/analysis/RuleConfiguredTargetBuilder.java
index 658e0a8..59494db 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/RuleConfiguredTargetBuilder.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/RuleConfiguredTargetBuilder.java
@@ -226,7 +226,7 @@
       // If the target is an analysis test that returned AnalysisTestResultInfo, register a
       // test pass/fail action on behalf of the target.
       AnalysisTestResultInfo testResultInfo =
-          providers.get(AnalysisTestResultInfo.SKYLARK_CONSTRUCTOR);
+          providers.get(AnalysisTestResultInfo.STARLARK_CONSTRUCTOR);
 
       if (testResultInfo == null) {
         ruleContext.ruleError(
@@ -319,7 +319,7 @@
 
         for (OutputGroupInfo outputGroup :
             ruleContext.getPrerequisites(
-                attributeName, TransitionMode.DONT_CHECK, OutputGroupInfo.SKYLARK_CONSTRUCTOR)) {
+                attributeName, TransitionMode.DONT_CHECK, OutputGroupInfo.STARLARK_CONSTRUCTOR)) {
 
           NestedSet<Artifact> validationArtifacts =
               outputGroup.getOutputGroup(OutputGroupInfo.VALIDATION);
@@ -485,7 +485,7 @@
       throw new EvalException(constructor.getLocation(),
           "All providers must be top level values");
     }
-    if (OutputGroupInfo.SKYLARK_CONSTRUCTOR.getKey().equals(constructor.getKey())) {
+    if (OutputGroupInfo.STARLARK_CONSTRUCTOR.getKey().equals(constructor.getKey())) {
       OutputGroupInfo outputGroupInfo = (OutputGroupInfo) provider;
       for (String outputGroup : outputGroupInfo) {
         addOutputGroup(outputGroup, outputGroupInfo.getOutputGroup(outputGroup));
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/config/BuildOptions.java b/src/main/java/com/google/devtools/build/lib/analysis/config/BuildOptions.java
index f404e1c3..14bb223 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/config/BuildOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/config/BuildOptions.java
@@ -77,7 +77,7 @@
 public final class BuildOptions implements Cloneable, Serializable {
   private static final Comparator<Class<? extends FragmentOptions>>
       lexicalFragmentOptionsComparator = Comparator.comparing(Class::getName);
-  private static final Comparator<Label> skylarkOptionsComparator = Ordering.natural();
+  private static final Comparator<Label> starlarkOptionsComparator = Ordering.natural();
   private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
 
   public static Map<Label, Object> labelizeStarlarkOptions(Map<String, Object> starlarkOptions) {
@@ -103,7 +103,7 @@
     for (FragmentOptions options : fragmentOptionsMap.values()) {
       builder.addFragmentOptions(options.getHost());
     }
-    return builder.addStarlarkOptions(skylarkOptionsMap).build();
+    return builder.addStarlarkOptions(starlarkOptionsMap).build();
   }
 
   /**
@@ -130,7 +130,7 @@
     for (FragmentOptions options : retainedOptions) {
       builder.addFragmentOptions(options);
     }
-    return builder.addStarlarkOptions(skylarkOptionsMap).build();
+    return builder.addStarlarkOptions(starlarkOptionsMap).build();
   }
 
   /**
@@ -171,8 +171,8 @@
    * Returns a BuildOptions class that only has Starlark options.
    */
   @VisibleForTesting
-  public static BuildOptions of(Map<Label, Object> skylarkOptions) {
-    return builder().addStarlarkOptions(skylarkOptions).build();
+  public static BuildOptions of(Map<Label, Object> starlarkOptions) {
+    return builder().addStarlarkOptions(starlarkOptions).build();
   }
 
   /** Returns the actual instance of a FragmentOptions class. */
@@ -195,7 +195,7 @@
     }
     keyBuilder.append(
         OptionsBase.mapToCacheKey(
-            skylarkOptionsMap.entrySet().stream()
+            starlarkOptionsMap.entrySet().stream()
                 .collect(Collectors.toMap(e -> e.getKey().toString(), Map.Entry::getValue))));
     return keyBuilder.toString();
   }
@@ -225,7 +225,7 @@
   }
 
   public ImmutableMap<Label, Object> getStarlarkOptions() {
-    return skylarkOptionsMap;
+    return starlarkOptionsMap;
   }
 
   /**
@@ -240,7 +240,7 @@
         fragmentOptionsMap.entrySet()) {
       nativeOptionsBuilder.put(entry.getKey(), entry.getValue().clone());
     }
-    return new BuildOptions(nativeOptionsBuilder.build(), ImmutableMap.copyOf(skylarkOptionsMap));
+    return new BuildOptions(nativeOptionsBuilder.build(), ImmutableMap.copyOf(starlarkOptionsMap));
   }
 
   private boolean fingerprintAndHashCodeInitialized() {
@@ -270,7 +270,7 @@
         fingerprint.addString(entry.getKey().getName());
         fingerprint.addString(entry.getValue().cacheKey());
       }
-      for (Map.Entry<Label, Object> entry : skylarkOptionsMap.entrySet()) {
+      for (Map.Entry<Label, Object> entry : starlarkOptionsMap.entrySet()) {
         fingerprint.addString(entry.getKey().toString());
         fingerprint.addString(entry.getValue().toString());
       }
@@ -307,14 +307,14 @@
   /** Maps options class definitions to FragmentOptions objects. */
   private final ImmutableMap<Class<? extends FragmentOptions>, FragmentOptions> fragmentOptionsMap;
   /** Maps Starlark options names to Starlark options values. */
-  private final ImmutableMap<Label, Object> skylarkOptionsMap;
+  private final ImmutableMap<Label, Object> starlarkOptionsMap;
 
   @AutoCodec.VisibleForSerialization
   BuildOptions(
       ImmutableMap<Class<? extends FragmentOptions>, FragmentOptions> fragmentOptionsMap,
-      ImmutableMap<Label, Object> skylarkOptionsMap) {
+      ImmutableMap<Label, Object> starlarkOptionsMap) {
     this.fragmentOptionsMap = fragmentOptionsMap;
-    this.skylarkOptionsMap = skylarkOptionsMap;
+    this.starlarkOptionsMap = starlarkOptionsMap;
   }
 
   public BuildOptions applyDiff(OptionsDiffForReconstruction optionsDiff) {
@@ -340,19 +340,19 @@
       builder.addFragmentOptions(extraSecondFragment);
     }
 
-    Map<Label, Object> skylarkOptions = new HashMap<>();
-    for (Map.Entry<Label, Object> buildSettingAndValue : skylarkOptionsMap.entrySet()) {
+    Map<Label, Object> starlarkOptions = new HashMap<>();
+    for (Map.Entry<Label, Object> buildSettingAndValue : starlarkOptionsMap.entrySet()) {
       Label buildSetting = buildSettingAndValue.getKey();
       if (optionsDiff.extraFirstStarlarkOptions.contains(buildSetting)) {
         continue;
       } else if (optionsDiff.differingStarlarkOptions.containsKey(buildSetting)) {
-        skylarkOptions.put(buildSetting, optionsDiff.differingStarlarkOptions.get(buildSetting));
+        starlarkOptions.put(buildSetting, optionsDiff.differingStarlarkOptions.get(buildSetting));
       } else {
-        skylarkOptions.put(buildSetting, skylarkOptionsMap.get(buildSetting));
+        starlarkOptions.put(buildSetting, starlarkOptionsMap.get(buildSetting));
       }
     }
-    skylarkOptions.putAll(optionsDiff.extraSecondStarlarkOptions);
-    reconstructedOptions = builder.addStarlarkOptions(skylarkOptions).build();
+    starlarkOptions.putAll(optionsDiff.extraSecondStarlarkOptions);
+    reconstructedOptions = builder.addStarlarkOptions(starlarkOptions).build();
     optionsDiff.cachedReconstructed = new SoftReference<>(reconstructedOptions);
     return reconstructedOptions;
   }
@@ -384,7 +384,7 @@
       }
     }
 
-    Map<Label, Object> starlarkOptions = new HashMap<>(skylarkOptionsMap);
+    Map<Label, Object> starlarkOptions = new HashMap<>(starlarkOptionsMap);
     Map<Label, Object> parsedStarlarkOptions =
         labelizeStarlarkOptions(parsingResult.getStarlarkOptions());
     for (Map.Entry<Label, Object> starlarkOption : parsedStarlarkOptions.entrySet()) {
@@ -467,7 +467,7 @@
     Map<Label, Object> starlarkOptions =
         labelizeStarlarkOptions(parsingResult.getStarlarkOptions());
     MapDifference<Label, Object> starlarkDifference =
-        Maps.difference(skylarkOptionsMap, starlarkOptions);
+        Maps.difference(starlarkOptionsMap, starlarkOptions);
     if (starlarkDifference.entriesInCommon().size() < starlarkOptions.size()) {
       return false;
     }
@@ -552,7 +552,7 @@
     public BuildOptions build() {
       return new BuildOptions(
           ImmutableSortedMap.copyOf(fragmentOptions, lexicalFragmentOptionsComparator),
-          ImmutableSortedMap.copyOf(starlarkOptions, skylarkOptionsComparator));
+          ImmutableSortedMap.copyOf(starlarkOptions, starlarkOptionsComparator));
     }
 
     private final Map<Class<? extends FragmentOptions>, FragmentOptions> fragmentOptions;
@@ -634,16 +634,16 @@
     }
 
     // Compare Starlark options for the two classes.
-    Map<Label, Object> skylarkFirst = first.getStarlarkOptions();
-    Map<Label, Object> skylarkSecond = second.getStarlarkOptions();
-    for (Label buildSetting : Sets.union(skylarkFirst.keySet(), skylarkSecond.keySet())) {
-      if (skylarkFirst.get(buildSetting) == null) {
-        diff.addExtraSecondStarlarkOption(buildSetting, skylarkSecond.get(buildSetting));
-      } else if (skylarkSecond.get(buildSetting) == null) {
+    Map<Label, Object> starlarkFirst = first.getStarlarkOptions();
+    Map<Label, Object> starlarkSecond = second.getStarlarkOptions();
+    for (Label buildSetting : Sets.union(starlarkFirst.keySet(), starlarkSecond.keySet())) {
+      if (starlarkFirst.get(buildSetting) == null) {
+        diff.addExtraSecondStarlarkOption(buildSetting, starlarkSecond.get(buildSetting));
+      } else if (starlarkSecond.get(buildSetting) == null) {
         diff.addExtraFirstStarlarkOption(buildSetting);
-      } else if (!skylarkFirst.get(buildSetting).equals(skylarkSecond.get(buildSetting))) {
+      } else if (!starlarkFirst.get(buildSetting).equals(starlarkSecond.get(buildSetting))) {
         diff.putStarlarkDiff(
-            buildSetting, skylarkFirst.get(buildSetting), skylarkSecond.get(buildSetting));
+            buildSetting, starlarkFirst.get(buildSetting), starlarkSecond.get(buildSetting));
       }
     }
     return diff;
@@ -727,7 +727,7 @@
             Comparator.comparing(o -> o.getClass().getName()), diff.extraSecondFragments),
         first.fingerprint,
         second.computeChecksum(),
-        diff.skylarkSecond,
+        diff.starlarkSecond,
         diff.extraStarlarkOptionsFirst,
         diff.extraStarlarkOptionsSecond,
         second);
@@ -751,10 +751,10 @@
     private final Set<Class<? extends FragmentOptions>> extraFirstFragments = new HashSet<>();
     private final Set<FragmentOptions> extraSecondFragments = new HashSet<>();
 
-    private final Map<Label, Object> skylarkFirst = new LinkedHashMap<>();
+    private final Map<Label, Object> starlarkFirst = new LinkedHashMap<>();
     // TODO(b/112041323): This should also be multimap but we don't diff multiple times with
     // Starlark options anywhere yet so add that feature when necessary.
-    private final Map<Label, Object> skylarkSecond = new LinkedHashMap<>();
+    private final Map<Label, Object> starlarkSecond = new LinkedHashMap<>();
 
     private final List<Label> extraStarlarkOptionsFirst = new ArrayList<>();
     private final Map<Label, Object> extraStarlarkOptionsSecond = new HashMap<>();
@@ -798,8 +798,8 @@
     }
 
     private void putStarlarkDiff(Label buildSetting, Object firstValue, Object secondValue) {
-      skylarkFirst.put(buildSetting, firstValue);
-      skylarkSecond.put(buildSetting, secondValue);
+      starlarkFirst.put(buildSetting, firstValue);
+      starlarkSecond.put(buildSetting, secondValue);
       hasStarlarkOptions = true;
     }
 
@@ -819,8 +819,8 @@
      */
     public Set<Label> getChangedStarlarkOptions() {
       return ImmutableSet.<Label>builder()
-          .addAll(skylarkFirst.keySet())
-          .addAll(skylarkSecond.keySet())
+          .addAll(starlarkFirst.keySet())
+          .addAll(starlarkSecond.keySet())
           .addAll(extraStarlarkOptionsFirst)
           .addAll(extraStarlarkOptionsSecond.keySet())
           .build();
@@ -828,12 +828,12 @@
 
     @VisibleForTesting
     Map<Label, Object> getStarlarkFirstForTesting() {
-      return skylarkFirst;
+      return starlarkFirst;
     }
 
     @VisibleForTesting
     Map<Label, Object> getStarlarkSecondForTesting() {
-      return skylarkSecond;
+      return starlarkSecond;
     }
 
     @VisibleForTesting
@@ -856,8 +856,8 @@
           && extraSecondFragments.isEmpty()
           && extraFirstFragments.isEmpty()
           && differingOptions.isEmpty()
-          && skylarkFirst.isEmpty()
-          && skylarkSecond.isEmpty()
+          && starlarkFirst.isEmpty()
+          && starlarkSecond.isEmpty()
           && extraStarlarkOptionsFirst.isEmpty()
           && extraStarlarkOptionsSecond.isEmpty();
     }
@@ -875,8 +875,8 @@
       first.forEach(
           (option, value) ->
               toReturn.add(option.getOptionName() + ":" + value + " -> " + second.get(option)));
-      skylarkFirst.forEach(
-          (option, value) -> toReturn.add(option + ":" + value + skylarkSecond.get(option)));
+      starlarkFirst.forEach(
+          (option, value) -> toReturn.add(option + ":" + value + starlarkSecond.get(option)));
       return toReturn;
     }
   }
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 1a38cc4..7d04a83 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
@@ -728,7 +728,7 @@
       help =
           "Add or remove keys from an action's execution info based on action mnemonic.  "
               + "Applies only to actions which support execution info. Many common actions "
-              + "support execution info, e.g. Genrule, CppCompile, Javac, SkylarkAction, "
+              + "support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction, "
               + "TestRunner. When specifying multiple values, order matters because "
               + "many regexes may apply to the same mnemonic.\n\n"
               + "Syntax: \"regex=[+-]key,[+-]key,...\".\n\n"
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/AbstractConfiguredTarget.java b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/AbstractConfiguredTarget.java
index 5d6951c..ab7cf51 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/AbstractConfiguredTarget.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/AbstractConfiguredTarget.java
@@ -75,8 +75,8 @@
           FILES_FIELD,
           DEFAULT_RUNFILES_FIELD,
           DATA_RUNFILES_FIELD,
-          FilesToRunProvider.SKYLARK_NAME,
-          OutputGroupInfo.SKYLARK_NAME,
+          FilesToRunProvider.STARLARK_NAME,
+          OutputGroupInfo.STARLARK_NAME,
           ACTIONS_FIELD_NAME);
 
   public AbstractConfiguredTarget(Label label, BuildConfigurationValue.Key configurationKey) {
@@ -192,21 +192,21 @@
   @Override
   public final ImmutableCollection<String> getFieldNames() {
     ImmutableList.Builder<String> result = ImmutableList.builder();
-    result.addAll(ImmutableList.of(
-        DATA_RUNFILES_FIELD,
-        DEFAULT_RUNFILES_FIELD,
-        LABEL_FIELD,
-        FILES_FIELD,
-        FilesToRunProvider.SKYLARK_NAME));
-    if (get(OutputGroupInfo.SKYLARK_CONSTRUCTOR) != null) {
-      result.add(OutputGroupInfo.SKYLARK_NAME);
+    result.addAll(
+        ImmutableList.of(
+            DATA_RUNFILES_FIELD,
+            DEFAULT_RUNFILES_FIELD,
+            LABEL_FIELD,
+            FILES_FIELD,
+            FilesToRunProvider.STARLARK_NAME));
+    if (get(OutputGroupInfo.STARLARK_CONSTRUCTOR) != null) {
+      result.add(OutputGroupInfo.STARLARK_NAME);
     }
-    addExtraSkylarkKeys(result::add);
+    addExtraStarlarkKeys(result::add);
     return result.build();
   }
 
-  protected void addExtraSkylarkKeys(Consumer<String> result) {
-  }
+  protected void addExtraStarlarkKeys(Consumer<String> result) {}
 
   private DefaultInfo getDefaultProvider() {
     if (defaultProvider.get() == null) {
@@ -248,10 +248,10 @@
         return getDefaultProvider().getDefaultRunfiles();
       case DATA_RUNFILES_FIELD:
         return getDefaultProvider().getDataRunfiles();
-      case FilesToRunProvider.SKYLARK_NAME:
+      case FilesToRunProvider.STARLARK_NAME:
         return getDefaultProvider().getFilesToRun();
-      case OutputGroupInfo.SKYLARK_NAME:
-        return get(OutputGroupInfo.SKYLARK_CONSTRUCTOR);
+      case OutputGroupInfo.STARLARK_NAME:
+        return get(OutputGroupInfo.STARLARK_CONSTRUCTOR);
       default:
         return rawGetStarlarkProvider(providerKey);
     }
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/MergedConfiguredTarget.java b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/MergedConfiguredTarget.java
index 6578ba3..68eb7d2 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/MergedConfiguredTarget.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/MergedConfiguredTarget.java
@@ -78,9 +78,9 @@
   }
 
   @Override
-  protected void addExtraSkylarkKeys(Consumer<String> result) {
+  protected void addExtraStarlarkKeys(Consumer<String> result) {
     if (base instanceof AbstractConfiguredTarget) {
-      ((AbstractConfiguredTarget) base).addExtraSkylarkKeys(result);
+      ((AbstractConfiguredTarget) base).addExtraStarlarkKeys(result);
     }
     for (int i = 0; i < nonBaseProviders.getProviderCount(); i++) {
       Object classAt = nonBaseProviders.getProviderKeyAt(i);
@@ -159,7 +159,7 @@
       TransitiveInfoProviderMap providers = aspect.getProviders();
       for (int i = 0; i < providers.getProviderCount(); ++i) {
         Object providerKey = providers.getProviderKeyAt(i);
-        if (OutputGroupInfo.SKYLARK_CONSTRUCTOR.getKey().equals(providerKey)
+        if (OutputGroupInfo.STARLARK_CONSTRUCTOR.getKey().equals(providerKey)
             || ExtraActionArtifactsProvider.class.equals(providerKey)
             || RequiredConfigFragmentsProvider.class.equals(providerKey)) {
           continue;
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/OutputFileConfiguredTarget.java b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/OutputFileConfiguredTarget.java
index 95a879c..8ba3006 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/OutputFileConfiguredTarget.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/OutputFileConfiguredTarget.java
@@ -74,7 +74,7 @@
         artifact,
         instrumentedFilesInfo(generatingRule),
         generatingRule.getProvider(RequiredConfigFragmentsProvider.class),
-        Preconditions.checkNotNull(generatingRule).get(OutputGroupInfo.SKYLARK_CONSTRUCTOR));
+        Preconditions.checkNotNull(generatingRule).get(OutputGroupInfo.STARLARK_CONSTRUCTOR));
 
     this.artifact = artifact;
     this.generatingRule = Preconditions.checkNotNull(generatingRule);
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
index e02f660..7281ede 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/configuredtargets/RuleConfiguredTarget.java
@@ -103,7 +103,7 @@
     Preconditions.checkState(providerBuilder.contains(FileProvider.class), label);
     Preconditions.checkState(providerBuilder.contains(FilesToRunProvider.class), label);
 
-    // Initialize every SkylarkApiProvider
+    // Initialize every StarlarkApiProvider
     for (int i = 0; i < providers.getProviderCount(); i++) {
       Object obj = providers.getProviderInstanceAt(i);
       if (obj instanceof StarlarkApiProvider) {
@@ -184,7 +184,7 @@
   }
 
   @Override
-  protected void addExtraSkylarkKeys(Consumer<String> result) {
+  protected void addExtraStarlarkKeys(Consumer<String> result) {
     for (int i = 0; i < providers.getProviderCount(); i++) {
       Object classAt = providers.getProviderKeyAt(i);
       if (classAt instanceof String) {
@@ -223,14 +223,14 @@
     // Provider key names might potentially be *private* information, and thus a comprehensive
     // list of provider keys should not be exposed in any way other than for debug information.
     printer.append("<target " + getLabel() + ", keys:[");
-    ImmutableList.Builder<String> skylarkProviderKeyStrings = ImmutableList.builder();
+    ImmutableList.Builder<String> starlarkProviderKeyStrings = ImmutableList.builder();
     for (int providerIndex = 0; providerIndex < providers.getProviderCount(); providerIndex++) {
       Object providerKey = providers.getProviderKeyAt(providerIndex);
       if (providerKey instanceof Provider.Key) {
-        skylarkProviderKeyStrings.add(providerKey.toString());
+        starlarkProviderKeyStrings.add(providerKey.toString());
       }
     }
-    printer.append(Joiner.on(", ").join(skylarkProviderKeyStrings.build()));
+    printer.append(Joiner.on(", ").join(starlarkProviderKeyStrings.build()));
     printer.append("]>");
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/skylark/Args.java b/src/main/java/com/google/devtools/build/lib/analysis/skylark/Args.java
index ebd7f90..b52fa9e 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/skylark/Args.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/skylark/Args.java
@@ -382,18 +382,18 @@
         throws EvalException {
       StarlarkCustomCommandLine.VectorArg.Builder vectorArg;
       if (value instanceof Depset) {
-        Depset skylarkNestedSet = (Depset) value;
-        NestedSet<?> nestedSet = skylarkNestedSet.getSet();
+        Depset starlarkNestedSet = (Depset) value;
+        NestedSet<?> nestedSet = starlarkNestedSet.getSet();
         if (expandDirectories) {
           potentialDirectoryArtifacts.add(nestedSet);
         }
         vectorArg = new StarlarkCustomCommandLine.VectorArg.Builder(nestedSet);
       } else {
-        Sequence<?> skylarkList = (Sequence) value;
+        Sequence<?> starlarkList = (Sequence) value;
         if (expandDirectories) {
-          scanForDirectories(skylarkList);
+          scanForDirectories(starlarkList);
         }
-        vectorArg = new StarlarkCustomCommandLine.VectorArg.Builder(skylarkList);
+        vectorArg = new StarlarkCustomCommandLine.VectorArg.Builder(starlarkList);
       }
       validateFormatString("format_each", formatEach);
       validateFormatString("format_joined", formatJoined);
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkLateBoundDefault.java b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkLateBoundDefault.java
index 05f615b..4e94932 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkLateBoundDefault.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkLateBoundDefault.java
@@ -41,7 +41,7 @@
  * 'label') specifically by Starlark configuration fragment name and field name, as registered by
  * {@link StarlarkConfigurationField}.
  *
- * <p>For example, a SkylarkLateBoundDefault on "java" and "toolchain" would require a valid
+ * <p>For example, a StarlarkLateBoundDefault on "java" and "toolchain" would require a valid
  * configuration fragment named "java" with a method annotated with {@link
  * StarlarkConfigurationField} of name "toolchain". This {@link LateBoundDefault} would provide a
  * late-bound dependency (defined by the label returned by that configuration field) in the current
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkModules.java b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkModules.java
index c2adbeb..05ab97f 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkModules.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/skylark/StarlarkModules.java
@@ -37,7 +37,7 @@
           new StarlarkNativeModule(),
           new StarlarkRuleClassFunctions(),
           StructProvider.STRUCT,
-          OutputGroupInfo.SKYLARK_CONSTRUCTOR,
+          OutputGroupInfo.STARLARK_CONSTRUCTOR,
           ActionsProvider.INSTANCE,
           DefaultInfo.PROVIDER);
 
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/test/AnalysisTestResultInfo.java b/src/main/java/com/google/devtools/build/lib/analysis/test/AnalysisTestResultInfo.java
index f485d48..2643fcd 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/test/AnalysisTestResultInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/test/AnalysisTestResultInfo.java
@@ -24,11 +24,8 @@
  */
 public class AnalysisTestResultInfo implements Info, AnalysisTestResultInfoApi {
 
-  /**
-   * Singleton provider instance for {@link AnalysisTestResultInfo}.
-   */
-  public static final TestResultInfoProvider SKYLARK_CONSTRUCTOR =
-      new TestResultInfoProvider();
+  /** Singleton provider instance for {@link AnalysisTestResultInfo}. */
+  public static final TestResultInfoProvider STARLARK_CONSTRUCTOR = new TestResultInfoProvider();
 
   private final Boolean success;
   private final String message;
@@ -40,7 +37,7 @@
 
   @Override
   public TestResultInfoProvider getProvider() {
-    return SKYLARK_CONSTRUCTOR;
+    return STARLARK_CONSTRUCTOR;
   }
 
   @Override
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
index 13a427e..0a1e65a 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
@@ -68,9 +68,9 @@
 
   @Override
   public Tuple<Object> compile(
-      StarlarkActionFactory skylarkActionFactoryApi,
-      FeatureConfigurationForStarlark skylarkFeatureConfiguration,
-      CcToolchainProvider skylarkCcToolchainProvider,
+      StarlarkActionFactory starlarkActionFactoryApi,
+      FeatureConfigurationForStarlark starlarkFeatureConfiguration,
+      CcToolchainProvider starlarkCcToolchainProvider,
       Sequence<?> sources, // <Artifact> expected
       Sequence<?> publicHeaders, // <Artifact> expected
       Sequence<?> privateHeaders, // <Artifact> expected
@@ -89,9 +89,9 @@
       StarlarkThread thread)
       throws EvalException, InterruptedException {
     return compile(
-        skylarkActionFactoryApi,
-        skylarkFeatureConfiguration,
-        skylarkCcToolchainProvider,
+        starlarkActionFactoryApi,
+        starlarkFeatureConfiguration,
+        starlarkCcToolchainProvider,
         sources,
         publicHeaders,
         privateHeaders,
@@ -116,8 +116,8 @@
   @Override
   public CcLinkingOutputs link(
       StarlarkActionFactory actions,
-      FeatureConfigurationForStarlark skylarkFeatureConfiguration,
-      CcToolchainProvider skylarkCcToolchainProvider,
+      FeatureConfigurationForStarlark starlarkFeatureConfiguration,
+      CcToolchainProvider starlarkCcToolchainProvider,
       Object compilationOutputs,
       Sequence<?> userLinkFlags, // <String> expected
       Sequence<?> linkingContexts, // <CcLinkingContext> expected
@@ -132,8 +132,8 @@
       throws InterruptedException, EvalException {
     return super.link(
         actions,
-        skylarkFeatureConfiguration,
-        skylarkCcToolchainProvider,
+        starlarkFeatureConfiguration,
+        starlarkCcToolchainProvider,
         convertFromNoneable(compilationOutputs, /* defaultValue= */ null),
         userLinkFlags,
         linkingContexts,
@@ -154,7 +154,7 @@
   }
 
   @Override
-  public CcCompilationOutputs mergeCcCompilationOutputsFromSkylark(Sequence<?> compilationOutputs)
+  public CcCompilationOutputs mergeCcCompilationOutputsFromStarlark(Sequence<?> compilationOutputs)
       throws EvalException {
     CcCompilationOutputs.Builder ccCompilationOutputsBuilder = CcCompilationOutputs.builder();
     for (CcCompilationOutputs ccCompilationOutputs :
diff --git a/src/main/java/com/google/devtools/build/lib/packages/AspectDefinition.java b/src/main/java/com/google/devtools/build/lib/packages/AspectDefinition.java
index aa8d0bd..abf181e 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/AspectDefinition.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/AspectDefinition.java
@@ -278,8 +278,8 @@
      * Asserts that this aspect can only be evaluated for rules that supply all of the specified
      * Starlark providers.
      */
-    public Builder requireSkylarkProviders(StarlarkProviderIdentifier... skylarkProviders) {
-      requiredProviders.addStarlarkSet(ImmutableSet.copyOf(skylarkProviders));
+    public Builder requireStarlarkProviders(StarlarkProviderIdentifier... starlarkProviders) {
+      requiredProviders.addStarlarkSet(ImmutableSet.copyOf(starlarkProviders));
       return this;
     }
 
diff --git a/src/main/java/com/google/devtools/build/lib/packages/BazelStarlarkContext.java b/src/main/java/com/google/devtools/build/lib/packages/BazelStarlarkContext.java
index 2e9a271..05c7f00 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/BazelStarlarkContext.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/BazelStarlarkContext.java
@@ -66,7 +66,7 @@
   // TODO(adonovan): clearly demarcate which fields are defined in which kinds of threads (loading,
   // analysis, workspace, implicit outputs, computed defaults, etc), perhaps by splitting these into
   // separate structs, exactly one of which is populated (plus the common fields). And eliminate
-  // SkylarkUtils.Phase.
+  // StarlarkUtils.Phase.
   // TODO(adonovan): move PackageFactory.PackageContext in here, for loading-phase threads.
   // TODO(adonovan): add a PackageIdentifier here, for use by the Starlark Label function.
   // TODO(adonovan): is there any reason not to put the entire RuleContext in this thread, for
diff --git a/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java b/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
index 0b96f4c..857b72d 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
@@ -414,7 +414,7 @@
       RootedPath buildFile,
       StarlarkFile file,
       Map<String, Module> loadedModules,
-      ImmutableList<Label> skylarkFileDependencies,
+      ImmutableList<Label> starlarkFileDependencies,
       RuleVisibility defaultVisibility,
       StarlarkSemantics starlarkSemantics,
       Globber globber)
@@ -431,7 +431,7 @@
           defaultVisibility,
           starlarkSemantics,
           loadedModules,
-          skylarkFileDependencies,
+          starlarkFileDependencies,
           repositoryMapping);
     } catch (InterruptedException e) {
       globber.onInterrupt();
@@ -526,7 +526,7 @@
                 buildFile,
                 file,
                 /*loadedModules=*/ ImmutableMap.<String, Module>of(),
-                /*skylarkFileDependencies=*/ ImmutableList.<Label>of(),
+                /*starlarkFileDependencies=*/ ImmutableList.<Label>of(),
                 /*defaultVisibility=*/ ConstantRuleVisibility.PUBLIC,
                 semantics,
                 globber)
@@ -702,7 +702,7 @@
       RuleVisibility defaultVisibility,
       StarlarkSemantics semantics,
       Map<String, Module> loadedModules,
-      ImmutableList<Label> skylarkFileDependencies,
+      ImmutableList<Label> starlarkFileDependencies,
       ImmutableMap<RepositoryName, RepositoryName> repositoryMapping)
       throws InterruptedException {
     Package.Builder pkgBuilder =
@@ -718,7 +718,7 @@
             // Let's give the BUILD file a chance to set default_visibility once,
             // by resetting the PackageBuilder.defaultVisibilitySet flag.
             .setDefaultVisibilitySet(false)
-            .setStarlarkFileDependencies(skylarkFileDependencies)
+            .setStarlarkFileDependencies(starlarkFileDependencies)
             .setWorkspaceName(workspaceName)
             .setThirdPartyLicenceExistencePolicy(
                 ruleClassProvider.getThirdPartyLicenseExistencePolicy());
@@ -823,7 +823,7 @@
               /*analysisRuleLabel=*/ null)
           .storeInThread(thread);
 
-      // TODO(adonovan): save this as a field in BazelSkylarkContext.
+      // TODO(adonovan): save this as a field in BazelStarlarkContext.
       // It needn't be a second thread-local.
       thread.setThreadLocal(PackageContext.class, pkgContext);
 
diff --git a/src/main/java/com/google/devtools/build/lib/packages/TargetUtils.java b/src/main/java/com/google/devtools/build/lib/packages/TargetUtils.java
index 2797f0d..2c964ef 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/TargetUtils.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/TargetUtils.java
@@ -272,7 +272,7 @@
    * @param rule a rule instance to get tags from
    * @param allowTagsPropagation if set to true, tags will be propagated from a target to the
    *     actions' execution requirements, for more details {@see
-   *     SkylarkSematicOptions#experimentalAllowTagsPropagation}
+   *     StarlarkSematicOptions#experimentalAllowTagsPropagation}
    */
   public static ImmutableMap<String, String> getFilteredExecutionInfo(
       @Nullable Object executionRequirementsUnchecked, Rule rule, boolean allowTagsPropagation)
diff --git a/src/main/java/com/google/devtools/build/lib/query2/query/output/XmlOutputFormatter.java b/src/main/java/com/google/devtools/build/lib/query2/query/output/XmlOutputFormatter.java
index 46b1487..5addac1 100644
--- a/src/main/java/com/google/devtools/build/lib/query2/query/output/XmlOutputFormatter.java
+++ b/src/main/java/com/google/devtools/build/lib/query2/query/output/XmlOutputFormatter.java
@@ -210,7 +210,7 @@
       elem = doc.createElement("source-file");
       InputFile inputFile = (InputFile) target;
       if (inputFile.getName().equals("BUILD")) {
-        addSkylarkFilesToElement(doc, elem, inputFile);
+        addStarlarkFilesToElement(doc, elem, inputFile);
         addFeaturesToElement(doc, elem, inputFile);
         elem.setAttribute("package_contains_errors",
             String.valueOf(inputFile.getPackage().containsErrors()));
@@ -272,14 +272,14 @@
     }
   }
 
-  private void addSkylarkFilesToElement(Document doc, Element parent, InputFile inputFile)
+  private void addStarlarkFilesToElement(Document doc, Element parent, InputFile inputFile)
       throws InterruptedException {
     Iterable<Label> dependencies =
         aspectResolver.computeBuildFileDependencies(inputFile.getPackage());
 
-    for (Label skylarkFileDep : dependencies) {
+    for (Label starlarkFileDep : dependencies) {
       Element elem = doc.createElement("load");
-      elem.setAttribute("name", skylarkFileDep.toString());
+      elem.setAttribute("name", starlarkFileDep.toString());
       parent.appendChild(elem);
     }
   }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidCommon.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidCommon.java
index ec0152f..ae34114 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidCommon.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidCommon.java
@@ -863,7 +863,7 @@
     NestedSetBuilder<Artifact> builder = NestedSetBuilder.stableOrder();
     for (OutputGroupInfo provider :
         getTransitivePrerequisites(
-            ruleContext, TransitionMode.TARGET, OutputGroupInfo.SKYLARK_CONSTRUCTOR)) {
+            ruleContext, TransitionMode.TARGET, OutputGroupInfo.STARLARK_CONSTRUCTOR)) {
       builder.addTransitive(provider.getOutputGroup(OutputGroupInfo.HIDDEN_TOP_LEVEL));
     }
     return builder.build();
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidDeviceScriptFixtureInfoProvider.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidDeviceScriptFixtureInfoProvider.java
index 9400d37..94aaf62 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidDeviceScriptFixtureInfoProvider.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidDeviceScriptFixtureInfoProvider.java
@@ -26,10 +26,10 @@
 @Immutable
 public class AndroidDeviceScriptFixtureInfoProvider extends NativeInfo {
 
-  private static final String SKYLARK_NAME = "DeviceScriptFixtureInfo";
-  public static final NativeProvider<AndroidDeviceScriptFixtureInfoProvider> SKYLARK_CONSTRUCTOR =
+  private static final String STARLARK_NAME = "DeviceScriptFixtureInfo";
+  public static final NativeProvider<AndroidDeviceScriptFixtureInfoProvider> STARLARK_CONSTRUCTOR =
       new NativeProvider<AndroidDeviceScriptFixtureInfoProvider>(
-          AndroidDeviceScriptFixtureInfoProvider.class, SKYLARK_NAME) {};
+          AndroidDeviceScriptFixtureInfoProvider.class, STARLARK_NAME) {};
 
   private final Artifact fixtureScript;
   private final NestedSet<Artifact> supportApks;
@@ -38,7 +38,7 @@
 
   public AndroidDeviceScriptFixtureInfoProvider(
       Artifact fixtureScript, NestedSet<Artifact> supportApks, boolean daemon, boolean strictExit) {
-    super(SKYLARK_CONSTRUCTOR);
+    super(STARLARK_CONSTRUCTOR);
     this.fixtureScript = fixtureScript;
     this.supportApks = supportApks;
     this.daemon = daemon;
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationInfo.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationInfo.java
index 5444dfe..ab267ce 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationInfo.java
@@ -26,7 +26,7 @@
 public class AndroidInstrumentationInfo extends NativeInfo
     implements AndroidInstrumentationInfoApi<ApkInfo> {
 
-  private static final String SKYLARK_NAME = "AndroidInstrumentationInfo";
+  private static final String STARLARK_NAME = "AndroidInstrumentationInfo";
 
   public static final AndroidInstrumentationInfoProvider PROVIDER =
       new AndroidInstrumentationInfoProvider();
@@ -49,7 +49,7 @@
       implements AndroidInstrumentationInfoApiProvider<ApkInfo> {
 
     private AndroidInstrumentationInfoProvider() {
-      super(SKYLARK_NAME, AndroidInstrumentationInfo.class);
+      super(STARLARK_NAME, AndroidInstrumentationInfo.class);
     }
 
     @Override
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationTestBase.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationTestBase.java
index cc47d78..dd349f9 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationTestBase.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidInstrumentationTestBase.java
@@ -236,7 +236,7 @@
         ruleContext.getPrerequisites(
             "fixtures",
             TransitionMode.TARGET,
-            AndroidDeviceScriptFixtureInfoProvider.SKYLARK_CONSTRUCTOR)) {
+            AndroidDeviceScriptFixtureInfoProvider.STARLARK_CONSTRUCTOR)) {
       allSupportApks.addTransitive(fixture.getSupportApks());
     }
     for (AndroidHostServiceFixtureInfoProvider fixture :
@@ -299,7 +299,7 @@
     return ruleContext.getPrerequisites(
         "fixtures",
         TransitionMode.TARGET,
-        AndroidDeviceScriptFixtureInfoProvider.SKYLARK_CONSTRUCTOR);
+        AndroidDeviceScriptFixtureInfoProvider.STARLARK_CONSTRUCTOR);
   }
 
   private static String getDeviceBrokerType(RuleContext ruleContext) {
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBaseRule.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBaseRule.java
index 2931c9f..41d5598 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBaseRule.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBaseRule.java
@@ -149,7 +149,7 @@
         /* <!-- #BLAZE_RULE($android_local_test_base).ATTRIBUTE(densities) -->
         Densities to filter for when building the apk. A corresponding compatible-screens
         section will also be added to the manifest if it does not already contain a
-        superset SkylarkListing.
+        superset StarlarkListing.
         <!-- #END_BLAZE_RULE.ATTRIBUTE --> */
         .add(attr("densities", STRING_LIST))
         .build();
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidNeverlinkAspect.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidNeverlinkAspect.java
index 2edb3e8..e1821d6 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidNeverlinkAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidNeverlinkAspect.java
@@ -95,8 +95,8 @@
     }
 
     return builder
-        .requireSkylarkProviders(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey()))
-        .requireSkylarkProviders(
+        .requireStarlarkProviders(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey()))
+        .requireStarlarkProviders(
             StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey()),
             StarlarkProviderIdentifier.forKey(
                 AndroidLibraryResourceClassJarProvider.PROVIDER.getKey()))
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/ApkInfo.java b/src/main/java/com/google/devtools/build/lib/rules/android/ApkInfo.java
index ef451b8..976df35 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/ApkInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/ApkInfo.java
@@ -26,7 +26,7 @@
 @Immutable
 public class ApkInfo extends NativeInfo implements ApkInfoApi<Artifact> {
 
-  private static final String SKYLARK_NAME = "ApkInfo";
+  private static final String STARLARK_NAME = "ApkInfo";
 
   /**
    * Provider instance for {@link ApkInfo}.
@@ -88,7 +88,7 @@
       implements ApkInfoApiProvider {
 
     private ApkInfoProvider() {
-      super(SKYLARK_NAME, ApkInfo.class);
+      super(STARLARK_NAME, ApkInfo.class);
     }
 
     @Override
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/DexArchiveAspect.java b/src/main/java/com/google/devtools/build/lib/rules/android/DexArchiveAspect.java
index ac59d0a..d033447 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/DexArchiveAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/DexArchiveAspect.java
@@ -134,12 +134,12 @@
   public AspectDefinition getDefinition(AspectParameters params) {
     AspectDefinition.Builder result =
         new AspectDefinition.Builder(this)
-            .requireSkylarkProviders(forKey(JavaInfo.PROVIDER.getKey()))
+            .requireStarlarkProviders(forKey(JavaInfo.PROVIDER.getKey()))
             // Latch onto Starlark toolchains in case they have a "runtime" (b/78647825)
-            .requireSkylarkProviders(forKey(ToolchainInfo.PROVIDER.getKey()))
+            .requireStarlarkProviders(forKey(ToolchainInfo.PROVIDER.getKey()))
             // For android_sdk rules, where we just want to get at aidl runtime deps.
-            .requireSkylarkProviders(forKey(AndroidSdkProvider.PROVIDER.getKey()))
-            .requireSkylarkProviders(forKey(ProtoInfo.PROVIDER.getKey()))
+            .requireStarlarkProviders(forKey(AndroidSdkProvider.PROVIDER.getKey()))
+            .requireStarlarkProviders(forKey(ProtoInfo.PROVIDER.getKey()))
             .requireProviderSets(
                 ImmutableList.of(
                     // For proto_lang_toolchain rules, where we just want to get at their runtime
diff --git a/src/main/java/com/google/devtools/build/lib/rules/apple/AvailableXcodesInfo.java b/src/main/java/com/google/devtools/build/lib/rules/apple/AvailableXcodesInfo.java
index 0fd538a..c44815e 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/apple/AvailableXcodesInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/apple/AvailableXcodesInfo.java
@@ -21,11 +21,11 @@
 @Immutable
 public class AvailableXcodesInfo extends NativeInfo {
   /** Starlark name for this provider. */
-  public static final String SKYLARK_NAME = "AvailableXcodesInfo";
+  public static final String STARLARK_NAME = "AvailableXcodesInfo";
 
   /** Provider identifier for {@link AvailableXcodesInfo}. */
   public static final BuiltinProvider<AvailableXcodesInfo> PROVIDER =
-      new BuiltinProvider<AvailableXcodesInfo>(SKYLARK_NAME, AvailableXcodesInfo.class) {};
+      new BuiltinProvider<AvailableXcodesInfo>(STARLARK_NAME, AvailableXcodesInfo.class) {};
 
   private final Iterable<XcodeVersionRuleData> availableXcodes;
   private final XcodeVersionRuleData defaultVersion;
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
index 0554a9c..14d9968 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
@@ -1075,7 +1075,7 @@
     NestedSetBuilder<Artifact> headerTokens = NestedSetBuilder.stableOrder();
     for (OutputGroupInfo dep :
         ruleContext.getPrerequisites(
-            "deps", TransitionMode.TARGET, OutputGroupInfo.SKYLARK_CONSTRUCTOR)) {
+            "deps", TransitionMode.TARGET, OutputGroupInfo.STARLARK_CONSTRUCTOR)) {
       headerTokens.addTransitive(dep.getOutputGroup(CcCompilationHelper.HIDDEN_HEADER_TOKENS));
     }
     if (cppConfiguration.processHeadersInDependencies()) {
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcInfo.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcInfo.java
index 0e2f0f5..e661e43 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcInfo.java
@@ -157,12 +157,12 @@
 
     @Override
     public CcInfoApi<Artifact> createInfo(
-        Object skylarkCcCompilationContext, Object skylarkCcLinkingInfo) throws EvalException {
+        Object starlarkCcCompilationContext, Object starlarkCcLinkingInfo) throws EvalException {
       CcCompilationContext ccCompilationContext =
-          nullIfNone(skylarkCcCompilationContext, CcCompilationContext.class);
+          nullIfNone(starlarkCcCompilationContext, CcCompilationContext.class);
       // TODO(b/118663806): Eventually only CcLinkingContext will be allowed, this is for
       // backwards compatibility.
-      CcLinkingContext ccLinkingContext = nullIfNone(skylarkCcLinkingInfo, CcLinkingContext.class);
+      CcLinkingContext ccLinkingContext = nullIfNone(starlarkCcLinkingInfo, CcLinkingContext.class);
       CcInfo.Builder ccInfoBuilder = CcInfo.builder();
       if (ccCompilationContext != null) {
         ccInfoBuilder.setCcCompilationContext(ccCompilationContext);
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
index dcc515c..91de1be 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
@@ -494,7 +494,7 @@
         ccCompilationOutputs.getFilesToCompile(processHeadersInDependencies, usePic));
     for (OutputGroupInfo dep :
         ruleContext.getPrerequisites(
-            "deps", TransitionMode.TARGET, OutputGroupInfo.SKYLARK_CONSTRUCTOR)) {
+            "deps", TransitionMode.TARGET, OutputGroupInfo.STARLARK_CONSTRUCTOR)) {
       artifactsToForceBuilder.addTransitive(
           dep.getOutputGroup(OutputGroupInfo.HIDDEN_TOP_LEVEL));
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/GoogleLegacyStubs.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/GoogleLegacyStubs.java
index 5a06dc9..3f16c02 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/GoogleLegacyStubs.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/GoogleLegacyStubs.java
@@ -62,7 +62,7 @@
           WrapCcIncludeProviderApi> {
 
     @Override
-    public FeatureConfigurationApi skylarkGetFeatureConfiguration(
+    public FeatureConfigurationApi starlarkGetFeatureConfiguration(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
         CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain)
         throws EvalException, InterruptedException {
@@ -70,13 +70,13 @@
     }
 
     @Override
-    public Depset skylarkCollectTransitiveSwigIncludes(
+    public Depset starlarkCollectTransitiveSwigIncludes(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
       return null;
     }
 
     @Override
-    public CompilationInfoApi<FileApi> skylarkCreateCompileActions(
+    public CompilationInfoApi<FileApi> starlarkCreateCompileActions(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
         FeatureConfigurationApi featureConfiguration,
         CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain,
@@ -89,7 +89,7 @@
     }
 
     @Override
-    public String skylarkGetMangledTargetName(
+    public String starlarkGetMangledTargetName(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext)
         throws EvalException, InterruptedException {
       return null;
@@ -140,25 +140,25 @@
 
     @Override
     public Sequence<String> getPyExtensionLinkopts(
-        StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
+        StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
       return null;
     }
 
     @Override
     public Depset getTransitivePythonSources(
-        StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext, FileApi pyFile) {
+        StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, FileApi pyFile) {
       return null;
     }
 
     @Override
     public RunfilesApi getPythonRunfiles(
-        StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext, Depset filesToBuild) {
+        StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, Depset filesToBuild) {
       return null;
     }
 
     @Override
     public PyWrapCcInfoApi<FileApi> getPyWrapCcInfo(
-        StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+        StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
         CcInfoApi<FileApi> ccInfo) {
       return null;
     }
@@ -185,7 +185,7 @@
           WrapCcIncludeProviderApi> {
 
     @Override
-    public RunfilesApi skylarkGetGoRunfiles(
+    public RunfilesApi starlarkGetGoRunfiles(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
       return null;
     }
@@ -196,7 +196,7 @@
     }
 
     @Override
-    public GoContextInfoApi skylarkCollectTransitiveGoContextGopkg(
+    public GoContextInfoApi starlarkCollectTransitiveGoContextGopkg(
         StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
         FileApi export,
         FileApi pkg,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/proto/CcProtoAspect.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/proto/CcProtoAspect.java
index eb6289d..1291c2f 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/proto/CcProtoAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/proto/CcProtoAspect.java
@@ -123,7 +123,7 @@
         new AspectDefinition.Builder(this)
             .propagateAlongAttribute("deps")
             .requiresConfigurationFragments(CppConfiguration.class, ProtoConfiguration.class)
-            .requireSkylarkProviders(ProtoInfo.PROVIDER.id())
+            .requireStarlarkProviders(ProtoInfo.PROVIDER.id())
             .addRequiredToolchains(ccToolchainType)
             .add(
                 attr(PROTO_TOOLCHAIN_ATTR, LABEL)
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/JavaConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/java/JavaConfiguration.java
index b64f585..022fd64 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/JavaConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/JavaConfiguration.java
@@ -216,7 +216,7 @@
   }
 
   @Override
-  // TODO(bazel-team): this is the command-line passed options, we should remove from skylark
+  // TODO(bazel-team): this is the command-line passed options, we should remove from Starlark
   // probably.
   public ImmutableList<String> getDefaultJavacFlags() {
     return commandLineJavacFlags;
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/JavaInfo.java b/src/main/java/com/google/devtools/build/lib/rules/java/JavaInfo.java
index be0e248..5ed0e72 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/JavaInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/JavaInfo.java
@@ -56,7 +56,7 @@
 @AutoCodec
 public final class JavaInfo extends NativeInfo implements JavaInfoApi<Artifact> {
 
-  public static final String SKYLARK_NAME = "JavaInfo";
+  public static final String STARLARK_NAME = "JavaInfo";
 
   public static final JavaInfoProvider PROVIDER = new JavaInfoProvider();
 
@@ -202,7 +202,7 @@
   /**
    * Returns a provider of the specified class, fetched from the specified target or, if not found,
    * from the JavaInfo of the given target. JavaInfo can be found as a declared provider in
-   * SkylarkProviders. Returns null if no such provider exists.
+   * StarlarkProviders. Returns null if no such provider exists.
    *
    * <p>A target can either have both the specified provider and JavaInfo that encapsulates the same
    * information, or just one of them.
@@ -421,7 +421,7 @@
   public static class JavaInfoProvider extends BuiltinProvider<JavaInfo>
       implements JavaInfoProviderApi {
     private JavaInfoProvider() {
-      super(SKYLARK_NAME, JavaInfo.class);
+      super(STARLARK_NAME, JavaInfo.class);
     }
 
     @Override
@@ -555,8 +555,8 @@
 
     public JavaInfo build() {
       // TODO(twerth): Clean up after we remove java_proto_library.strict_deps.
-      // Instead of teaching every (potential Skylark) caller to also create the provider for strict
-      // deps we wrap the non strict provider instead.
+      // Instead of teaching every (potential Starlark) caller to also create the provider for
+      // strict deps we wrap the non strict provider instead.
       if (!providerMap.contains(JavaStrictCompilationArgsProvider.class)
           && providerMap.contains(JavaCompilationArgsProvider.class)) {
         JavaStrictCompilationArgsProvider javaStrictCompilationArgsProvider =
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/JavaRuntimeInfo.java b/src/main/java/com/google/devtools/build/lib/rules/java/JavaRuntimeInfo.java
index 74fae69..8ddd414 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/JavaRuntimeInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/JavaRuntimeInfo.java
@@ -165,7 +165,7 @@
   }
 
   @Override
-  public Depset skylarkJavaBaseInputs() {
+  public Depset starlarkJavaBaseInputs() {
     return Depset.of(Artifact.TYPE, javaBaseInputs());
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/MessageBundleInfo.java b/src/main/java/com/google/devtools/build/lib/rules/java/MessageBundleInfo.java
index c1bd690..7598da0 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/MessageBundleInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/MessageBundleInfo.java
@@ -40,7 +40,7 @@
 @Immutable
 public final class MessageBundleInfo extends NativeInfo implements StarlarkValue {
 
-  public static final String SKYLARK_NAME = "MessageBundleInfo";
+  public static final String STARLARK_NAME = "MessageBundleInfo";
 
   /** Provider singleton constant. */
   public static final BuiltinProvider<MessageBundleInfo> PROVIDER = new Provider();
@@ -49,7 +49,7 @@
   @StarlarkBuiltin(name = "Provider", documented = false, doc = "")
   public static class Provider extends BuiltinProvider<MessageBundleInfo> implements ProviderApi {
     private Provider() {
-      super(SKYLARK_NAME, MessageBundleInfo.class);
+      super(STARLARK_NAME, MessageBundleInfo.class);
     }
 
     @StarlarkMethod(
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaLiteProtoAspect.java b/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaLiteProtoAspect.java
index 4cb8a6e..8ad5f09 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaLiteProtoAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaLiteProtoAspect.java
@@ -109,7 +109,7 @@
             .propagateAlongAttribute("exports")
             .requiresConfigurationFragments(
                 JavaConfiguration.class, ProtoConfiguration.class, PlatformConfiguration.class)
-            .requireSkylarkProviders(ProtoInfo.PROVIDER.id())
+            .requireStarlarkProviders(ProtoInfo.PROVIDER.id())
             .advertiseProvider(JavaProtoLibraryAspectProvider.class)
             .advertiseProvider(
                 ImmutableList.of(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey())))
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaProtoAspect.java b/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaProtoAspect.java
index da1cece..92ea921 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaProtoAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/proto/JavaProtoAspect.java
@@ -118,7 +118,7 @@
             .propagateAlongAttribute("exports")
             .requiresConfigurationFragments(
                 JavaConfiguration.class, ProtoConfiguration.class, PlatformConfiguration.class)
-            .requireSkylarkProviders(ProtoInfo.PROVIDER.id())
+            .requireStarlarkProviders(ProtoInfo.PROVIDER.id())
             .advertiseProvider(JavaProtoLibraryAspectProvider.class)
             .advertiseProvider(
                 ImmutableList.of(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey())))
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcAspect.java b/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcAspect.java
index 9f12bdd..a0cc57d 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcAspect.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcAspect.java
@@ -144,8 +144,8 @@
         .propagateAlongAttribute("deps")
         .propagateAlongAttribute("exports")
         .propagateAlongAttribute("runtime_deps")
-        .requireSkylarkProviders(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey()))
-        .requireSkylarkProviders(ProtoInfo.PROVIDER.id())
+        .requireStarlarkProviders(StarlarkProviderIdentifier.forKey(JavaInfo.PROVIDER.getKey()))
+        .requireStarlarkProviders(ProtoInfo.PROVIDER.id())
         .advertiseProvider(ImmutableList.of(ObjcProvider.STARLARK_CONSTRUCTOR.id()))
         .requiresConfigurationFragments(
             AppleConfiguration.class,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/test/TestingSupportRules.java b/src/main/java/com/google/devtools/build/lib/rules/test/TestingSupportRules.java
index 233f688..caa9481 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/test/TestingSupportRules.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/test/TestingSupportRules.java
@@ -37,7 +37,7 @@
             new StarlarkTestingModule(),
             new CoverageCommon(),
             AnalysisFailureInfo.SKYLARK_CONSTRUCTOR,
-            AnalysisTestResultInfo.SKYLARK_CONSTRUCTOR));
+            AnalysisTestResultInfo.STARLARK_CONSTRUCTOR));
   }
 
   @Override
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/AutoRegistry.java b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/AutoRegistry.java
index a63c212..1e09de2 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/AutoRegistry.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/AutoRegistry.java
@@ -56,9 +56,9 @@
           "java.lang.StackTraceElement",
           "java.lang.invoke.SerializedLambda",
           "com.google.common.base.Predicates$InPredicate",
-          // Sadly, these builders are serialized as part of SkylarkCustomCommandLine$Builder, which
-          // apparently can be preserved through analysis. We may investigate if this actually has
-          // performance/correctness implications.
+          // Sadly, these builders are serialized as part of StarlarkCustomCommandLine$Builder,
+          // which apparently can be preserved through analysis. We may investigate if this actually
+          // has performance/correctness implications.
           "com.google.common.collect.ImmutableList$Builder");
 
   private static final ImmutableList<Object> REFERENCE_CONSTANTS_TO_REGISTER =
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/StarlarkRuleFunctionsApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/StarlarkRuleFunctionsApi.java
index 9c40fc8..4505b9a 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/StarlarkRuleFunctionsApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/StarlarkRuleFunctionsApi.java
@@ -356,7 +356,7 @@
       Boolean outputToGenfiles,
       Sequence<?> fragments,
       Sequence<?> hostFragments,
-      Boolean skylarkTestable,
+      Boolean starlarkTestable,
       Sequence<?> toolchains,
       String doc,
       Sequence<?> providesArg,
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/BazelCcModuleApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/BazelCcModuleApi.java
index 01995db..2012f17 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/BazelCcModuleApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/BazelCcModuleApi.java
@@ -34,10 +34,10 @@
     name = "cc_common",
     doc = "Utilities for C++ compilation, linking, and command line generation.")
 public interface BazelCcModuleApi<
-        SkylarkActionFactoryT extends StarlarkActionFactoryApi,
+        StarlarkActionFactoryT extends StarlarkActionFactoryApi,
         FileT extends FileApi,
         ConstraintValueT extends ConstraintValueInfoApi,
-        SkylarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
+        StarlarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
         CcToolchainProviderT extends CcToolchainProviderApi<FeatureConfigurationT>,
         FeatureConfigurationT extends FeatureConfigurationApi,
         CompilationContextT extends CcCompilationContextApi<FileT>,
@@ -49,7 +49,7 @@
         CcToolchainVariablesT extends CcToolchainVariablesApi,
         CcToolchainConfigInfoT extends CcToolchainConfigInfoApi>
     extends CcModuleApi<
-        SkylarkActionFactoryT,
+        StarlarkActionFactoryT,
         FileT,
         CcToolchainProviderT,
         FeatureConfigurationT,
@@ -59,7 +59,7 @@
         LibraryToLinkT,
         CcToolchainVariablesT,
         ConstraintValueT,
-        SkylarkRuleContextT,
+        StarlarkRuleContextT,
         CcToolchainConfigInfoT,
         CompilationOutputsT> {
 
@@ -217,9 +217,9 @@
             type = Sequence.class),
       })
   Tuple<Object> compile(
-      SkylarkActionFactoryT skylarkActionFactoryApi,
-      FeatureConfigurationT skylarkFeatureConfiguration,
-      CcToolchainProviderT skylarkCcToolchainProvider,
+      StarlarkActionFactoryT starlarkActionFactoryApi,
+      FeatureConfigurationT starlarkFeatureConfiguration,
+      CcToolchainProviderT starlarkCcToolchainProvider,
       Sequence<?> sources, // <FileT> expected
       Sequence<?> publicHeaders, // <FileT> expected
       Sequence<?> privateHeaders, // <FileT> expected
@@ -345,9 +345,9 @@
             allowedTypes = {@ParamType(type = FileApi.class), @ParamType(type = NoneType.class)}),
       })
   LinkingOutputsT link(
-      SkylarkActionFactoryT skylarkActionFactoryApi,
-      FeatureConfigurationT skylarkFeatureConfiguration,
-      CcToolchainProviderT skylarkCcToolchainProvider,
+      StarlarkActionFactoryT starlarkActionFactoryApi,
+      FeatureConfigurationT starlarkFeatureConfiguration,
+      CcToolchainProviderT starlarkCcToolchainProvider,
       Object compilationOutputs,
       Sequence<?> userLinkFlags, // <String> expected
       Sequence<?> linkingContexts, // <LinkingContextT> expected
@@ -396,7 +396,7 @@
             defaultValue = "[]",
             type = Sequence.class),
       })
-  CompilationOutputsT mergeCcCompilationOutputsFromSkylark(
+  CompilationOutputsT mergeCcCompilationOutputsFromStarlark(
       Sequence<?> compilationOutputs) // <CompilationOutputsT> expected
       throws EvalException;
 }
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcModuleApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcModuleApi.java
index f4ad7d4..37a0f87 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcModuleApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcModuleApi.java
@@ -39,7 +39,7 @@
     name = "cc_common",
     doc = "Utilities for C++ compilation, linking, and command line generation.")
 public interface CcModuleApi<
-        SkylarkActionFactoryT extends StarlarkActionFactoryApi,
+        StarlarkActionFactoryT extends StarlarkActionFactoryApi,
         FileT extends FileApi,
         CcToolchainProviderT extends CcToolchainProviderApi<?>,
         FeatureConfigurationT extends FeatureConfigurationApi,
@@ -49,7 +49,7 @@
         LibraryToLinkT extends LibraryToLinkApi<FileT>,
         CcToolchainVariablesT extends CcToolchainVariablesApi,
         ConstraintValueT extends ConstraintValueInfoApi,
-        SkylarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
+        StarlarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
         CcToolchainConfigInfoT extends CcToolchainConfigInfoApi,
         CompilationOutputsT extends CcCompilationOutputsApi<FileT>>
     extends StarlarkValue {
@@ -820,7 +820,7 @@
             doc = "The rule context."),
       },
       doc = "Returns true if the --incompatible_enable_cc_toolchain_resolution flag is enabled.")
-  boolean isCcToolchainResolutionEnabled(SkylarkRuleContextT ruleContext);
+  boolean isCcToolchainResolutionEnabled(StarlarkRuleContextT ruleContext);
 
   @StarlarkMethod(
       name = "create_cc_toolchain_config_info",
@@ -965,7 +965,7 @@
             doc = "Internal purpose only, do not use."),
       })
   CcToolchainConfigInfoT ccToolchainConfigInfoFromStarlark(
-      SkylarkRuleContextT skylarkRuleContext,
+      StarlarkRuleContextT starlarkRuleContext,
       Sequence<?> features, // <StructApi> expected
       Sequence<?> actionConfigs, // <StructApi> expected
       Sequence<?> artifactNamePatterns, // <StructApi> expected
@@ -1085,9 +1085,9 @@
             allowedTypes = {@ParamType(type = FileApi.class), @ParamType(type = NoneType.class)}),
       })
   Tuple<Object> createLinkingContextFromCompilationOutputs(
-      SkylarkActionFactoryT skylarkActionFactoryApi,
-      FeatureConfigurationT skylarkFeatureConfiguration,
-      CcToolchainProviderT skylarkCcToolchainProvider,
+      StarlarkActionFactoryT starlarkActionFactoryApi,
+      FeatureConfigurationT starlarkFeatureConfiguration,
+      CcToolchainProviderT starlarkCcToolchainProvider,
       CompilationOutputsT compilationOutputs,
       Sequence<?> userLinkFlags, // <String> expected
       Sequence<?> linkingContexts, // <LinkingContextT> expected
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/GoWrapCcHelperApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/GoWrapCcHelperApi.java
index ae42dbb..5578ec6 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/GoWrapCcHelperApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/GoWrapCcHelperApi.java
@@ -75,7 +75,7 @@
         @Param(name = "ctx", positional = false, named = true, type = StarlarkRuleContextApi.class),
       })
   // TODO(b/113797843): Not written in Starlark because of GoRunfilesProvider.
-  public RunfilesApi skylarkGetGoRunfiles(SkylarkRuleContextT skylarkRuleContext)
+  public RunfilesApi starlarkGetGoRunfiles(SkylarkRuleContextT skylarkRuleContext)
       throws EvalException, InterruptedException;
 
   @StarlarkMethod(
@@ -109,7 +109,7 @@
             }),
         @Param(name = "cc_info", positional = false, named = true, type = CcInfoApi.class),
       })
-  public GoContextInfoT skylarkCollectTransitiveGoContextGopkg(
+  public GoContextInfoT starlarkCollectTransitiveGoContextGopkg(
       SkylarkRuleContextT skylarkRuleContext,
       FileT export,
       FileT pkg,
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/PyWrapCcHelperApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/PyWrapCcHelperApi.java
index 049d56f..a2a6c04 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/PyWrapCcHelperApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/PyWrapCcHelperApi.java
@@ -41,7 +41,7 @@
 public interface PyWrapCcHelperApi<
         FileT extends FileApi,
         ConstraintValueT extends ConstraintValueInfoApi,
-        SkylarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
+        StarlarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
         CcInfoT extends CcInfoApi<FileT>,
         FeatureConfigurationT extends FeatureConfigurationApi,
         CcToolchainProviderT extends CcToolchainProviderApi<FeatureConfigurationT>,
@@ -51,7 +51,7 @@
     extends WrapCcHelperApi<
         FeatureConfigurationT,
         ConstraintValueT,
-        SkylarkRuleContextT,
+        StarlarkRuleContextT,
         CcToolchainProviderT,
         CompilationInfoT,
         FileT,
@@ -66,7 +66,7 @@
         @Param(name = "ctx", positional = false, named = true, type = StarlarkRuleContextApi.class),
       })
   // TODO(plf): PyExtension is not in Starlark.
-  public Sequence<String> getPyExtensionLinkopts(SkylarkRuleContextT skylarkRuleContext)
+  public Sequence<String> getPyExtensionLinkopts(StarlarkRuleContextT starlarkRuleContext)
       throws EvalException, InterruptedException;
 
   @StarlarkMethod(
@@ -78,7 +78,7 @@
         @Param(name = "py_file", positional = false, named = true, type = FileApi.class),
       })
   // TODO(plf): Not written in Starlark because of PyCommon.
-  public Depset getTransitivePythonSources(SkylarkRuleContextT skylarkRuleContext, FileT pyFile)
+  public Depset getTransitivePythonSources(StarlarkRuleContextT starlarkRuleContext, FileT pyFile)
       throws EvalException, InterruptedException;
 
   @StarlarkMethod(
@@ -90,7 +90,8 @@
         @Param(name = "files_to_build", positional = false, named = true, type = Depset.class),
       })
   // TODO(plf): Not written in Starlark because of PythonRunfilesProvider.
-  public RunfilesApi getPythonRunfiles(SkylarkRuleContextT skylarkRuleContext, Depset filesToBuild)
+  public RunfilesApi getPythonRunfiles(
+      StarlarkRuleContextT starlarkRuleContext, Depset filesToBuild)
       throws EvalException, InterruptedException;
 
   @StarlarkMethod(
@@ -103,6 +104,6 @@
       })
   // TODO(plf): PyWrapCcInfo is not written in Starlark because several native rules use it.
   public PyWrapCcInfoApi<FileT> getPyWrapCcInfo(
-      SkylarkRuleContextT skylarkRuleContext, CcInfoT ccInfo)
+      StarlarkRuleContextT starlarkRuleContext, CcInfoT ccInfo)
       throws EvalException, InterruptedException;
 }
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/WrapCcHelperApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/WrapCcHelperApi.java
index f07b8e7..4e8a286 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/WrapCcHelperApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/WrapCcHelperApi.java
@@ -59,7 +59,7 @@
             named = true,
             type = CcToolchainProviderApi.class),
       })
-  public FeatureConfigurationT skylarkGetFeatureConfiguration(
+  public FeatureConfigurationT starlarkGetFeatureConfiguration(
       SkylarkRuleContextT skylarkRuleContext, CcToolchainProviderT ccToolchain)
       throws EvalException, InterruptedException;
 
@@ -69,7 +69,7 @@
       parameters = {
         @Param(name = "ctx", positional = false, named = true, type = StarlarkRuleContextApi.class),
       })
-  public Depset skylarkCollectTransitiveSwigIncludes(SkylarkRuleContextT skylarkRuleContext);
+  public Depset starlarkCollectTransitiveSwigIncludes(SkylarkRuleContextT skylarkRuleContext);
 
   @StarlarkMethod(
       name = "create_compile_actions",
@@ -95,7 +95,7 @@
             type = Sequence.class),
         @Param(name = "target_copts", positional = false, named = true, type = Sequence.class),
       })
-  public CompilationInfoT skylarkCreateCompileActions(
+  public CompilationInfoT starlarkCreateCompileActions(
       SkylarkRuleContextT skylarkRuleContext,
       FeatureConfigurationT featureConfiguration,
       CcToolchainProviderT ccToolchain,
@@ -112,7 +112,7 @@
       parameters = {
         @Param(name = "ctx", positional = false, named = true, type = StarlarkRuleContextApi.class),
       })
-  public String skylarkGetMangledTargetName(SkylarkRuleContextT skylarkRuleContext)
+  public String starlarkGetMangledTargetName(SkylarkRuleContextT skylarkRuleContext)
       throws EvalException, InterruptedException;
 
   @StarlarkMethod(
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaConfigurationApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaConfigurationApi.java
index e671130..ee5e700 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaConfigurationApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaConfigurationApi.java
@@ -32,7 +32,7 @@
       name = "default_javac_flags",
       structField = true,
       doc = "The default flags for the Java compiler.")
-  // TODO(bazel-team): this is the command-line passed options, we should remove from skylark
+  // TODO(bazel-team): this is the command-line passed options, we should remove from Starlark
   // probably.
   ImmutableList<String> getDefaultJavacFlags();
 
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaProtoCommonApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaProtoCommonApi.java
index b3a0d46..fcd0553 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaProtoCommonApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaProtoCommonApi.java
@@ -29,7 +29,7 @@
 public interface JavaProtoCommonApi<
         FileT extends FileApi,
         ConstraintValueT extends ConstraintValueInfoApi,
-        SkylarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
+        StarlarkRuleContextT extends StarlarkRuleContextApi<ConstraintValueT>,
         TransitiveInfoCollectionT extends TransitiveInfoCollectionApi>
     extends StarlarkValue {
 
@@ -64,7 +64,7 @@
             defaultValue = "'java'")
       })
   void createProtoCompileAction(
-      SkylarkRuleContextT skylarkRuleContext,
+      StarlarkRuleContextT starlarkRuleContext,
       TransitiveInfoCollectionT target,
       FileT sourceJar,
       String protoToolchainAttr,
@@ -101,5 +101,5 @@
         @Param(name = "proto_toolchain_attr", positional = false, named = true, type = String.class)
       })
   JavaInfoApi<FileT> getRuntimeToolchainProvider(
-      SkylarkRuleContextT skylarkRuleContext, String protoToolchainAttr) throws EvalException;
+      StarlarkRuleContextT starlarkRuleContext, String protoToolchainAttr) throws EvalException;
 }
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaRuntimeInfoApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaRuntimeInfoApi.java
index fb28176..b2a5533 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaRuntimeInfoApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/java/JavaRuntimeInfoApi.java
@@ -67,5 +67,5 @@
       name = "files",
       doc = "Returns the files in the Java runtime.",
       structField = true)
-  Depset skylarkJavaBaseInputs();
+  Depset starlarkJavaBaseInputs();
 }
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/test/CoverageCommonApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/test/CoverageCommonApi.java
index 7022214..2ef958b 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/test/CoverageCommonApi.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/test/CoverageCommonApi.java
@@ -76,7 +76,7 @@
             type = Sequence.class),
       })
   InstrumentedFilesInfoApi instrumentedFilesInfo(
-      RuleContextT skylarkRuleContext,
+      RuleContextT starlarkRuleContext,
       Sequence<?> sourceAttributes, // <String> expected
       Sequence<?> dependencyAttributes, // <String> expected
       Object extensions)
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Dict.java b/src/main/java/com/google/devtools/build/lib/syntax/Dict.java
index d846e75..9855581 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Dict.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Dict.java
@@ -173,7 +173,7 @@
       allowReturnNones = true,
       useStarlarkThread = true)
   // TODO(adonovan): This method is named get2 as a temporary workaround for a bug in
-  // SkylarkInterfaceUtils.getStarlarkMethod. The two 'get' methods cause it to get
+  // StarlarkInterfaceUtils.getStarlarkMethod. The two 'get' methods cause it to get
   // confused as to which one has the annotation. Fix it and remove "2" suffix.
   public Object get2(Object key, Object defaultValue, StarlarkThread thread) throws EvalException {
     Object v = this.get(key);
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/EvalUtils.java b/src/main/java/com/google/devtools/build/lib/syntax/EvalUtils.java
index 0384e43..d977fa1 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/EvalUtils.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/EvalUtils.java
@@ -28,7 +28,7 @@
   private EvalUtils() {}
 
   /**
-   * The exception that SKYLARK_COMPARATOR might throw. This is an unchecked exception because
+   * The exception that STARLARK_COMPARATOR might throw. This is an unchecked exception because
    * Comparator doesn't let us declare exceptions. It should normally be caught and wrapped in an
    * EvalException.
    */
@@ -46,7 +46,7 @@
    */
   // TODO(adonovan): consider what API to expose around comparison and ordering. Java's three-valued
   // comparator cannot properly handle weakly or partially ordered values such as IEEE754 floats.
-  static final Ordering<Object> SKYLARK_COMPARATOR =
+  static final Ordering<Object> STARLARK_COMPARATOR =
       new Ordering<Object>() {
         private int compareLists(Sequence<?> o1, Sequence<?> o2) {
           if (o1 instanceof RangeList || o2 instanceof RangeList) {
@@ -517,7 +517,7 @@
   /** Implements comparison operators. */
   private static int compare(Object x, Object y) throws EvalException {
     try {
-      return SKYLARK_COMPARATOR.compare(x, y);
+      return STARLARK_COMPARATOR.compare(x, y);
     } catch (ComparisonException e) {
       throw new EvalException(null, e.getMessage());
     }
@@ -571,7 +571,7 @@
     if (object instanceof StarlarkIndexable) {
       Object result = ((StarlarkIndexable) object).getIndex(semantics, key);
       // TODO(bazel-team): We shouldn't have this fromJava call here. If it's needed at all,
-      // it should go in the implementations of SkylarkIndexable#getIndex that produce non-Starlark
+      // it should go in the implementations of StarlarkIndexable#getIndex that produce non-Starlark
       // values.
       return result == null ? null : Starlark.fromJava(result, mu);
     } else if (object instanceof String) {
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
index f31d759..556f3b3 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
@@ -50,7 +50,7 @@
       extraPositionals = @Param(name = "args", doc = "The elements to be checked."))
   public Object min(Sequence<?> args) throws EvalException {
     try {
-      return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR.reverse());
+      return findExtreme(args, EvalUtils.STARLARK_COMPARATOR.reverse());
     } catch (ComparisonException e) {
       throw new EvalException(null, e);
     }
@@ -67,7 +67,7 @@
       extraPositionals = @Param(name = "args", doc = "The elements to be checked."))
   public Object max(Sequence<?> args) throws EvalException {
     try {
-      return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR);
+      return findExtreme(args, EvalUtils.STARLARK_COMPARATOR);
     } catch (ComparisonException e) {
       throw new EvalException(null, e);
     }
@@ -163,7 +163,7 @@
     Object[] array = Starlark.toArray(iterable);
     if (key == Starlark.NONE) {
       try {
-        Arrays.sort(array, EvalUtils.SKYLARK_COMPARATOR);
+        Arrays.sort(array, EvalUtils.STARLARK_COMPARATOR);
       } catch (EvalUtils.ComparisonException e) {
         throw Starlark.errorf("%s", e.getMessage());
       }
@@ -176,7 +176,7 @@
         @Override
         public int compare(Object x, Object y) {
           try {
-            return EvalUtils.SKYLARK_COMPARATOR.compare(callKeyFunc(x), callKeyFunc(y));
+            return EvalUtils.STARLARK_COMPARATOR.compare(callKeyFunc(x), callKeyFunc(y));
           } catch (InterruptedException | EvalException e) {
             if (this.e == null) {
               this.e = e;
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Starlark.java b/src/main/java/com/google/devtools/build/lib/syntax/Starlark.java
index f2e101d..8a37866 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Starlark.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Starlark.java
@@ -243,7 +243,7 @@
 
     } else if (StarlarkCallable.class.isAssignableFrom(c)) {
       // All callable values have historically been lumped together as "function".
-      // TODO(adonovan): built-in types that don't use SkylarkModule should report
+      // TODO(adonovan): built-in types that don't use StarlarkModule should report
       // their own type string, but this is a breaking change as users often
       // use type(x)=="function" for Starlark and built-in functions.
       return "function";
diff --git a/src/main/java/com/google/devtools/build/skydoc/SkydocMain.java b/src/main/java/com/google/devtools/build/skydoc/SkydocMain.java
index 266b473..b6cc035 100644
--- a/src/main/java/com/google/devtools/build/skydoc/SkydocMain.java
+++ b/src/main/java/com/google/devtools/build/skydoc/SkydocMain.java
@@ -155,7 +155,7 @@
  * <p>Usage:
  *
  * <pre>
- *   skydoc {target_skylark_file_label} {output_file} [symbol_name]...
+ *   skydoc {target_starlark_file_label} {output_file} [symbol_name]...
  * </pre>
  *
  * <p>Generates documentation for all exported symbols of the target Starlark file that are
@@ -411,7 +411,7 @@
   }
 
   /**
-   * Recursively evaluates/interprets the Starlark file at a given path and its transitive skylark
+   * Recursively evaluates/interprets the Starlark file at a given path and its transitive Starlark
    * dependencies using a fake build API and collects information about all rule definitions made in
    * those files.
    *
@@ -470,7 +470,7 @@
     }
 
     Module module =
-        evalSkylarkBody(semantics, file, imports, ruleInfoList, providerInfoList, aspectInfoList);
+        evalStarlarkBody(semantics, file, imports, ruleInfoList, providerInfoList, aspectInfoList);
 
     pending.remove(path);
     loaded.put(path, module);
@@ -499,7 +499,7 @@
   }
 
   /** Evaluates the AST from a single Starlark file, given the already-resolved imports. */
-  private static Module evalSkylarkBody(
+  private static Module evalStarlarkBody(
       StarlarkSemantics semantics,
       StarlarkFile file,
       Map<String, Module> imports,
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/FakeStarlarkRuleFunctionsApi.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/FakeStarlarkRuleFunctionsApi.java
index c359f5f..f6553be 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/FakeStarlarkRuleFunctionsApi.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/FakeStarlarkRuleFunctionsApi.java
@@ -126,7 +126,7 @@
       Boolean outputToGenfiles,
       Sequence<?> fragments,
       Sequence<?> hostFragments,
-      Boolean skylarkTestable,
+      Boolean starlarkTestable,
       Sequence<?> toolchains,
       String doc,
       Sequence<?> providesArg,
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeCcModule.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeCcModule.java
index f090057..b3a1cb42 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeCcModule.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeCcModule.java
@@ -225,8 +225,8 @@
   @Override
   public Tuple<Object> compile(
       StarlarkActionFactoryApi starlarkActionFactoryApi,
-      FeatureConfigurationApi skylarkFeatureConfiguration,
-      CcToolchainProviderApi<FeatureConfigurationApi> skylarkCcToolchainProvider,
+      FeatureConfigurationApi starlarkFeatureConfiguration,
+      CcToolchainProviderApi<FeatureConfigurationApi> starlarkCcToolchainProvider,
       Sequence<?> sources,
       Sequence<?> publicHeaders,
       Sequence<?> privateHeaders,
@@ -250,8 +250,8 @@
   @Override
   public Tuple<Object> createLinkingContextFromCompilationOutputs(
       StarlarkActionFactoryApi starlarkActionFactoryApi,
-      FeatureConfigurationApi skylarkFeatureConfiguration,
-      CcToolchainProviderApi<FeatureConfigurationApi> skylarkCcToolchainProvider,
+      FeatureConfigurationApi starlarkFeatureConfiguration,
+      CcToolchainProviderApi<FeatureConfigurationApi> starlarkCcToolchainProvider,
       CcCompilationOutputsApi<FileApi> compilationOutputs,
       Sequence<?> userLinkFlags,
       Sequence<?> ccLinkingContextApis,
@@ -270,8 +270,8 @@
   @Override
   public CcLinkingOutputsApi<FileApi> link(
       StarlarkActionFactoryApi starlarkActionFactoryApi,
-      FeatureConfigurationApi skylarkFeatureConfiguration,
-      CcToolchainProviderApi<FeatureConfigurationApi> skylarkCcToolchainProvider,
+      FeatureConfigurationApi starlarkFeatureConfiguration,
+      CcToolchainProviderApi<FeatureConfigurationApi> starlarkCcToolchainProvider,
       Object compilationOutputs,
       Sequence<?> userLinkFlags,
       Sequence<?> linkingContexts,
@@ -289,7 +289,7 @@
 
   @Override
   public CcToolchainConfigInfoApi ccToolchainConfigInfoFromStarlark(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       Sequence<?> features,
       Sequence<?> actionConfigs,
       Sequence<?> artifactNamePatterns,
@@ -317,7 +317,7 @@
   }
 
   @Override
-  public CcCompilationOutputsApi<FileApi> mergeCcCompilationOutputsFromSkylark(
+  public CcCompilationOutputsApi<FileApi> mergeCcCompilationOutputsFromStarlark(
       Sequence<?> compilationOutputs) {
     return null;
   }
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeGoWrapCcHelper.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeGoWrapCcHelper.java
index df472e1..c2324c8 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeGoWrapCcHelper.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakeGoWrapCcHelper.java
@@ -54,7 +54,7 @@
         WrapCcIncludeProviderApi> {
 
   @Override
-  public RunfilesApi skylarkGetGoRunfiles(
+  public RunfilesApi starlarkGetGoRunfiles(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
@@ -65,12 +65,12 @@
   }
 
   @Override
-  public GoContextInfoApi skylarkCollectTransitiveGoContextGopkg(
+  public GoContextInfoApi starlarkCollectTransitiveGoContextGopkg(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       FileApi export,
       FileApi pkg,
       FileApi gopkg,
-      Object skylarkWrapContext,
+      Object starlarkWrapContext,
       CcInfoApi<FileApi> ccInfo) {
     return null;
   }
@@ -110,7 +110,7 @@
   @Override
   public GoPackageInfoApi createTransitiveGopackageInfo(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
-      FileApi skylarkGopkg,
+      FileApi starlarkGopkg,
       FileApi export,
       FileApi swigOutGo) {
     return null;
@@ -118,25 +118,25 @@
 
   @Override
   public Depset /*<FileApi>*/ getGopackageFilesForStarlark(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, FileApi skylarkGopkg) {
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, FileApi starlarkGopkg) {
     return null;
   }
 
   @Override
-  public FeatureConfigurationApi skylarkGetFeatureConfiguration(
+  public FeatureConfigurationApi starlarkGetFeatureConfiguration(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain) {
     return null;
   }
 
   @Override
-  public Depset skylarkCollectTransitiveSwigIncludes(
+  public Depset starlarkCollectTransitiveSwigIncludes(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
 
   @Override
-  public CompilationInfoApi<FileApi> skylarkCreateCompileActions(
+  public CompilationInfoApi<FileApi> starlarkCreateCompileActions(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       FeatureConfigurationApi featureConfiguration,
       CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain,
@@ -148,7 +148,7 @@
   }
 
   @Override
-  public String skylarkGetMangledTargetName(
+  public String starlarkGetMangledTargetName(
       StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakePyWrapCcHelper.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakePyWrapCcHelper.java
index a8ef0d5..6cce3f8 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakePyWrapCcHelper.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/cpp/FakePyWrapCcHelper.java
@@ -44,57 +44,57 @@
 
   @Override
   public Sequence<String> getPyExtensionLinkopts(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
 
   @Override
   public Depset getTransitivePythonSources(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext, FileApi pyFile) {
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, FileApi pyFile) {
     return null;
   }
 
   @Override
   public RunfilesApi getPythonRunfiles(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext, Depset filesToBuild) {
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, Depset filesToBuild) {
     return null;
   }
 
   @Override
   public PyWrapCcInfoApi<FileApi> getPyWrapCcInfo(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       CcInfoApi<FileApi> ccInfo) {
     return null;
   }
 
   @Override
-  public FeatureConfigurationApi skylarkGetFeatureConfiguration(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+  public FeatureConfigurationApi starlarkGetFeatureConfiguration(
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain) {
     return null;
   }
 
   @Override
-  public Depset skylarkCollectTransitiveSwigIncludes(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
+  public Depset starlarkCollectTransitiveSwigIncludes(
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
 
   @Override
-  public String skylarkGetMangledTargetName(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext) {
+  public String starlarkGetMangledTargetName(
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext) {
     return null;
   }
 
   @Override
   public WrapCcIncludeProviderApi getWrapCcIncludeProvider(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext, Depset swigIncludes) {
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext, Depset swigIncludes) {
     return null;
   }
 
   @Override
   public void registerSwigAction(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain,
       FeatureConfigurationApi featureConfiguration,
       CcCompilationContextApi<FileApi> wrapperCcCompilationContext,
@@ -111,8 +111,8 @@
       Object zipTool) {}
 
   @Override
-  public CompilationInfoApi<FileApi> skylarkCreateCompileActions(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+  public CompilationInfoApi<FileApi> starlarkCreateCompileActions(
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       FeatureConfigurationApi featureConfiguration,
       CcToolchainProviderApi<FeatureConfigurationApi> ccToolchain,
       FileApi ccFile,
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaCommon.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaCommon.java
index 970dcb5..3ffafbf 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaCommon.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaCommon.java
@@ -47,7 +47,7 @@
 
   @Override
   public FakeJavaInfo createJavaCompileAction(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       Sequence<?> sourceJars,
       Sequence<?> sourceFiles,
       FileApi outputJar,
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaRuntimeInfoApi.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaRuntimeInfoApi.java
index a395f6e..5586263 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaRuntimeInfoApi.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/java/FakeJavaRuntimeInfoApi.java
@@ -42,7 +42,7 @@
   }
 
   @Override
-  public Depset skylarkJavaBaseInputs() {
+  public Depset starlarkJavaBaseInputs() {
     return null;
   }
 
diff --git a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/test/FakeCoverageCommon.java b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/test/FakeCoverageCommon.java
index 484191e..46d1063 100644
--- a/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/test/FakeCoverageCommon.java
+++ b/src/main/java/com/google/devtools/build/skydoc/fakebuildapi/test/FakeCoverageCommon.java
@@ -28,7 +28,7 @@
 
   @Override
   public InstrumentedFilesInfoApi instrumentedFilesInfo(
-      StarlarkRuleContextApi<ConstraintValueInfoApi> skylarkRuleContext,
+      StarlarkRuleContextApi<ConstraintValueInfoApi> starlarkRuleContext,
       Sequence<?> sourceAttributes,
       Sequence<?> dependencyAttributes,
       Object extensions) {
