Rename StarlarkImportLookupFunction and friends
This renames "StarlarkImportLookup*" to "BzlLoad*", and also changes a number of uses of "import" to "load". This helps keep names to a more manageable length and is in line with modern Starlark terminology.
This is refactoring work toward adding a new kind of .bzl loading context, for Bazel-internal .bzl files.
Work toward #11437.
RELNOTES: None
PiperOrigin-RevId: 313240742
diff --git a/src/main/java/com/google/devtools/build/lib/packages/WorkspaceFileValue.java b/src/main/java/com/google/devtools/build/lib/packages/WorkspaceFileValue.java
index 43c7867..c9b6af9 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/WorkspaceFileValue.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/WorkspaceFileValue.java
@@ -102,7 +102,7 @@
private final boolean hasNext;
private final ImmutableMap<String, Object> bindings;
private final ImmutableMap<String, Module> loadedModules;
- private final ImmutableMap<String, Integer> importToChunkMap;
+ private final ImmutableMap<String, Integer> loadToChunkMap;
private final ImmutableMap<RepositoryName, ImmutableMap<RepositoryName, RepositoryName>>
repositoryMapping;
// Mapping of the relative paths of the incrementally updated managed directories
@@ -118,8 +118,8 @@
* @param pkg Package built by agreggating all parts of the split WORKSPACE file up to this one.
* @param loadedModules modules loaded by load statements in chunks of the WORKSPACE file up to
* this one.
- * @param importToChunkMap Map of all load statements encountered so far to the chunk they
- * initially appeared in.
+ * @param loadToChunkMap Map of all load statements encountered so far to the chunk they initially
+ * appeared in.
* @param bindings List of top-level variable bindings from the all parts of the split WORKSPACE
* file up to this one. The key is the name of the bindings and the value is the actual
* object.
@@ -133,7 +133,7 @@
public WorkspaceFileValue(
Package pkg,
Map<String, Module> loadedModules,
- Map<String, Integer> importToChunkMap,
+ Map<String, Integer> loadToChunkMap,
Map<String, Object> bindings,
RootedPath path,
int idx,
@@ -146,7 +146,7 @@
this.hasNext = hasNext;
this.bindings = ImmutableMap.copyOf(bindings);
this.loadedModules = ImmutableMap.copyOf(loadedModules);
- this.importToChunkMap = ImmutableMap.copyOf(importToChunkMap);
+ this.loadToChunkMap = ImmutableMap.copyOf(loadToChunkMap);
this.repositoryMapping = pkg.getExternalPackageRepositoryMappings();
this.managedDirectories = managedDirectories;
this.doNotSymlinkInExecrootPaths = doNotSymlinkInExecrootPaths;
@@ -223,8 +223,8 @@
return loadedModules;
}
- public ImmutableMap<String, Integer> getImportToChunkMap() {
- return importToChunkMap;
+ public ImmutableMap<String, Integer> getLoadToChunkMap() {
+ return loadToChunkMap;
}
public ImmutableMap<RepositoryName, ImmutableMap<RepositoryName, RepositoryName>>
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
index 28b7ecb..ee6628a 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/AspectFunction.java
@@ -63,9 +63,9 @@
import com.google.devtools.build.lib.packages.Type.ConversionException;
import com.google.devtools.build.lib.profiler.memory.CurrentRuleTracker;
import com.google.devtools.build.lib.skyframe.AspectValueKey.AspectKey;
+import com.google.devtools.build.lib.skyframe.BzlLoadFunction.BzlLoadFailedException;
import com.google.devtools.build.lib.skyframe.ConfiguredTargetFunction.ConfiguredTargetFunctionException;
import com.google.devtools.build.lib.skyframe.SkyframeExecutor.BuildViewProvider;
-import com.google.devtools.build.lib.skyframe.StarlarkImportLookupFunction.StarlarkImportFailedException;
import com.google.devtools.build.lib.util.OrderedSetMultimap;
import com.google.devtools.build.skyframe.SkyFunction;
import com.google.devtools.build.skyframe.SkyFunctionException;
@@ -154,18 +154,17 @@
static StarlarkAspect loadStarlarkAspect(
Environment env, Label extensionLabel, String starlarkValueName)
throws AspectCreationException, InterruptedException {
- SkyKey importFileKey = StarlarkImportLookupValue.packageBzlKey(extensionLabel);
+ SkyKey importFileKey = BzlLoadValue.packageBzlKey(extensionLabel);
try {
- StarlarkImportLookupValue starlarkImportLookupValue =
- (StarlarkImportLookupValue)
- env.getValueOrThrow(importFileKey, StarlarkImportFailedException.class);
- if (starlarkImportLookupValue == null) {
+ BzlLoadValue bzlLoadValue =
+ (BzlLoadValue) env.getValueOrThrow(importFileKey, BzlLoadFailedException.class);
+ if (bzlLoadValue == null) {
Preconditions.checkState(
env.valuesMissing(), "no Starlark import value for %s", importFileKey);
return null;
}
- Object starlarkValue = starlarkImportLookupValue.getModule().getGlobal(starlarkValueName);
+ Object starlarkValue = bzlLoadValue.getModule().getGlobal(starlarkValueName);
if (starlarkValue == null) {
throw new ConversionException(
String.format(
@@ -177,7 +176,7 @@
"%s from %s is not an aspect", starlarkValueName, extensionLabel.toString()));
}
return (StarlarkAspect) starlarkValue;
- } catch (StarlarkImportFailedException | ConversionException e) {
+ } catch (BzlLoadFailedException | ConversionException e) {
env.getListener().handle(Event.error(e.getMessage()));
throw new AspectCreationException(e.getMessage(), extensionLabel);
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/BUILD b/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
index ce4b33f..098c34b 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/BUILD
@@ -27,6 +27,7 @@
"BazelSkyframeExecutorConstants.java",
"BuildConfigurationFunction.java",
"BuildInfoCollectionFunction.java",
+ "BzlLoadFunction.java",
"CompletionFunction.java",
"ConfiguredTargetCycleReporter.java",
"ConfiguredTargetFunction.java",
@@ -72,7 +73,6 @@
"StarlarkAspectFactory.java",
"StarlarkBuiltinsFunction.java",
"StarlarkBuiltinsValue.java",
- "StarlarkImportLookupFunction.java",
"TargetCompletionValue.java",
"TargetCompletor.java",
"TargetPatternFunction.java",
@@ -127,8 +127,9 @@
":blacklisted_package_prefixes_value",
":build_configuration_value",
":build_info_collection_value",
- ":cached_starlark_import_lookup_value_and_deps",
- ":cached_starlark_import_lookup_value_and_deps_builder_factory",
+ ":bzl_load_value",
+ ":cached_bzl_load_value_and_deps",
+ ":cached_bzl_load_value_and_deps_builder_factory",
":client_environment_function",
":client_environment_value",
":collect_packages_under_directory_function",
@@ -198,7 +199,6 @@
":skyframe_incremental_build_monitor",
":skylark_module_cycle_reporter",
":starlark_file_dependency",
- ":starlark_import_lookup_value",
":state_informing_sky_function_environment",
":target_pattern_error_function",
":target_pattern_phase_value",
@@ -942,10 +942,10 @@
)
java_library(
- name = "cached_starlark_import_lookup_value_and_deps",
- srcs = ["CachedStarlarkImportLookupValueAndDeps.java"],
+ name = "cached_bzl_load_value_and_deps",
+ srcs = ["CachedBzlLoadValueAndDeps.java"],
deps = [
- ":starlark_import_lookup_value",
+ ":bzl_load_value",
"//src/main/java/com/google/devtools/build/skyframe:skyframe-objects",
"//third_party:auto_value",
"//third_party:guava",
@@ -953,10 +953,10 @@
)
java_library(
- name = "cached_starlark_import_lookup_value_and_deps_builder_factory",
- srcs = ["CachedStarlarkImportLookupValueAndDepsBuilderFactory.java"],
+ name = "cached_bzl_load_value_and_deps_builder_factory",
+ srcs = ["CachedBzlLoadValueAndDepsBuilderFactory.java"],
deps = [
- ":cached_starlark_import_lookup_value_and_deps",
+ ":cached_bzl_load_value_and_deps",
"//src/main/java/com/google/devtools/build/lib/concurrent",
"//third_party:guava",
],
@@ -2268,9 +2268,9 @@
srcs = ["StarlarkModuleCycleReporter.java"],
deps = [
":abstract_label_cycle_reporter",
+ ":bzl_load_value",
":repository_value",
":sky_functions",
- ":starlark_import_lookup_value",
"//src/main/java/com/google/devtools/build/lib/cmdline",
"//src/main/java/com/google/devtools/build/lib/events",
"//src/main/java/com/google/devtools/build/lib/packages",
@@ -2292,8 +2292,8 @@
)
java_library(
- name = "starlark_import_lookup_value",
- srcs = ["StarlarkImportLookupValue.java"],
+ name = "bzl_load_value",
+ srcs = ["BzlLoadValue.java"],
deps = [
":sky_functions",
":starlark_file_dependency",
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadFunction.java
similarity index 68%
rename from src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupFunction.java
rename to src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadFunction.java
index 16acbe7..c122bdb 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadFunction.java
@@ -75,12 +75,11 @@
*
* <p>Given a {@link Label} referencing a .bzl file, attempts to locate the file and load it. The
* Label must be absolute, and must not reference the special {@code external} package. If loading
- * is successful, returns a {@link StarlarkImportLookupValue} that encapsulates the loaded {@link
- * Module} and its transitive digest and {@link StarlarkFileDependency} information. If loading is
- * unsuccessful, throws a {@link StarlarkImportLookupFunctionException} that encapsulates the cause
- * of the failure.
+ * is successful, returns a {@link BzlLoadValue} that encapsulates the loaded {@link Module} and its
+ * transitive digest and {@link StarlarkFileDependency} information. If loading is unsuccessful,
+ * throws a {@link BzlLoadFunctionException} that encapsulates the cause of the failure.
*/
-public class StarlarkImportLookupFunction implements SkyFunction {
+public class BzlLoadFunction implements SkyFunction {
// Creates the BazelStarlarkContext and populates the predeclared .bzl symbols.
private final RuleClassProvider ruleClassProvider;
@@ -92,7 +91,7 @@
private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
- private StarlarkImportLookupFunction(
+ private BzlLoadFunction(
RuleClassProvider ruleClassProvider,
PackageFactory packageFactory,
ASTFileLookupValueManager astFileLookupValueManager,
@@ -103,31 +102,31 @@
this.selfInliningManager = selfInliningManager;
}
- public static StarlarkImportLookupFunction create(
+ public static BzlLoadFunction create(
RuleClassProvider ruleClassProvider,
PackageFactory packageFactory,
DigestHashFunction digestHashFunction,
Cache<Label, ASTFileLookupValue> astFileLookupValueCache) {
- return new StarlarkImportLookupFunction(
+ return new BzlLoadFunction(
ruleClassProvider,
packageFactory,
- // When we are not inlining StarlarkImportLookupValue nodes, there is no need to have
- // separate ASTFileLookupValue nodes for bzl files. Instead we inline them for a strict
- // memory win, at a small code complexity cost.
+ // When we are not inlining BzlLoadValue nodes, there is no need to have separate
+ // ASTFileLookupValue nodes for bzl files. Instead we inline them for a strict memory win,
+ // at a small code complexity cost.
//
// Detailed explanation:
// (1) The ASTFileLookupValue node for a bzl file is used only for the computation of
- // that file's StarlarkImportLookupValue node. So there's no concern about duplicate
- // work that would otherwise get deduped by Skyframe.
+ // that file's BzlLoadValue node. So there's no concern about duplicate work that would
+ // otherwise get deduped by Skyframe.
// (2) ASTFileLookupValue doesn't have an interesting equality relation, so we have no
// hope of getting any interesting change-pruning of ASTFileLookupValue nodes. If we
// had an interesting equality relation that was e.g. able to ignore benign
// whitespace, then there would be a hypothetical benefit to having separate
// ASTFileLookupValue nodes (e.g. on incremental builds we'd be able to not re-execute
// top-level code in bzl files if the file were reparsed to an equivalent AST).
- // (3) A ASTFileLookupValue node lets us avoid redoing work on a
- // StarlarkImportLookupFunction Skyframe restart, but we can also achieve that result
- // ourselves with a cache that persists between Skyframe restarts.
+ // (3) A ASTFileLookupValue node lets us avoid redoing work on a BzlLoadFunction Skyframe
+ // restart, but we can also achieve that result ourselves with a cache that persists between
+ // Skyframe restarts.
//
// Therefore, ASTFileLookupValue nodes are wasteful from two perspectives:
// (a) ASTFileLookupValue contains a StarlarkFile, and that business object is really
@@ -139,72 +138,69 @@
/*selfInliningManager=*/ null);
}
- public static StarlarkImportLookupFunction createForInliningSelfForPackageAndWorkspaceNodes(
+ public static BzlLoadFunction createForInliningSelfForPackageAndWorkspaceNodes(
RuleClassProvider ruleClassProvider,
PackageFactory packageFactory,
- int starlarkImportLookupValueCacheSize) {
- return new StarlarkImportLookupFunction(
+ int bzlLoadValueCacheSize) {
+ return new BzlLoadFunction(
ruleClassProvider,
packageFactory,
- // When we are inlining StarlarkImportLookupValue nodes, then we want to have explicit
- // ASTFileLookupValue nodes, since now (1) in the comment above doesn't hold. This way we
- // read and parse each needed bzl file at most once total globally, rather than once per
- // need (in the worst-case of a StarlarkImportLookupValue inlining cache miss). This is
- // important in the situation where a bzl file is loaded by a lot of other bzl files or
- // BUILD files.
+ // When we are inlining BzlLoadValue nodes, then we want to have explicit ASTFileLookupValue
+ // nodes, since now (1) in the comment above doesn't hold. This way we read and parse each
+ // needed bzl file at most once total globally, rather than once per need (in the worst-case
+ // of a BzlLoadValue inlining cache miss). This is important in the situation where a bzl
+ // file is loaded by a lot of other bzl files or BUILD files.
RegularSkyframeASTFileLookupValueManager.INSTANCE,
- new SelfInliningManager(starlarkImportLookupValueCacheSize));
+ new SelfInliningManager(bzlLoadValueCacheSize));
}
@Override
@Nullable
public SkyValue compute(SkyKey skyKey, Environment env)
throws SkyFunctionException, InterruptedException {
- StarlarkImportLookupValue.Key key = (StarlarkImportLookupValue.Key) skyKey.argument();
+ BzlLoadValue.Key key = (BzlLoadValue.Key) skyKey.argument();
try {
return computeInternal(key, env, /*inliningState=*/ null);
} catch (InconsistentFilesystemException e) {
- throw new StarlarkImportLookupFunctionException(e, Transience.PERSISTENT);
- } catch (StarlarkImportFailedException e) {
- throw new StarlarkImportLookupFunctionException(e);
+ throw new BzlLoadFunctionException(e, Transience.PERSISTENT);
+ } catch (BzlLoadFailedException e) {
+ throw new BzlLoadFunctionException(e);
}
}
@Nullable
- StarlarkImportLookupValue computeWithSelfInlineCallsForPackageAndWorkspaceNodes(
- StarlarkImportLookupValue.Key key,
+ BzlLoadValue computeWithSelfInlineCallsForPackageAndWorkspaceNodes(
+ BzlLoadValue.Key key,
Environment env,
- Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- visitedDepsInToplevelLoad)
- throws InconsistentFilesystemException, StarlarkImportFailedException, InterruptedException {
+ Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDepsInToplevelLoad)
+ throws InconsistentFilesystemException, BzlLoadFailedException, InterruptedException {
Preconditions.checkNotNull(selfInliningManager);
// See comments in computeWithSelfInlineCallsInternal for an explanation of the visitedNested
// and visitedDepsInToplevelLoad vars.
- CachedStarlarkImportLookupValueAndDeps cachedStarlarkImportLookupValueAndDeps =
+ CachedBzlLoadValueAndDeps cachedBzlLoadValueAndDeps =
computeWithSelfInlineCallsInternal(
key,
env,
// visitedNested must use insertion order to display the correct error.
/*visitedNested=*/ new LinkedHashSet<>(),
/*visitedDepsInToplevelLoad=*/ visitedDepsInToplevelLoad);
- if (cachedStarlarkImportLookupValueAndDeps == null) {
+ if (cachedBzlLoadValueAndDeps == null) {
return null;
}
- return cachedStarlarkImportLookupValueAndDeps.getValue();
+ return cachedBzlLoadValueAndDeps.getValue();
}
@Nullable
- private CachedStarlarkImportLookupValueAndDeps computeWithSelfInlineCallsInternal(
- StarlarkImportLookupValue.Key key,
+ private CachedBzlLoadValueAndDeps computeWithSelfInlineCallsInternal(
+ BzlLoadValue.Key key,
Environment env,
- Set<StarlarkImportLookupValue.Key> visitedNested,
- Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- visitedDepsInToplevelLoad)
- throws InconsistentFilesystemException, StarlarkImportFailedException, InterruptedException {
- // Under StarlarkImportLookupFunction inlining, BUILD and WORKSPACE files are evaluated in
- // separate Skyframe threads, but all the .bzls transitively loaded by a single package occur in
- // one thread. All these threads share a global cache in selfInliningManager, so that once any
- // thread completes evaluation of a .bzl, it needn't be evaluated again (unless it's evicted).
+ Set<BzlLoadValue.Key> visitedNested,
+ Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDepsInToplevelLoad)
+ throws InconsistentFilesystemException, BzlLoadFailedException, InterruptedException {
+ // Under BzlLoadFunction inlining, BUILD and WORKSPACE files are evaluated in separate Skyframe
+ // threads, but all the .bzls transitively loaded by a single package occur in one thread. All
+ // these threads share a global cache in selfInliningManager, so that once any thread completes
+ // evaluation of a .bzl, it needn't be evaluated again (unless it's evicted).
//
// If two threads race to evaluate the same .bzl, each one will see a different copy of it, and
// only one will end up in the global cache. This presents a hazard if the same BUILD or
@@ -223,18 +219,15 @@
// (We don't need to worry about Starlark values from different packages interacting since
// inlining is only used for the loading phase.)
//
- CachedStarlarkImportLookupValueAndDeps cachedStarlarkImportLookupValueAndDeps =
- visitedDepsInToplevelLoad.get(key);
- if (cachedStarlarkImportLookupValueAndDeps == null) {
- cachedStarlarkImportLookupValueAndDeps =
- selfInliningManager.starlarkImportLookupValueCache.getIfPresent(key);
- if (cachedStarlarkImportLookupValueAndDeps != null) {
- cachedStarlarkImportLookupValueAndDeps.traverse(
- env::registerDependencies, visitedDepsInToplevelLoad);
+ CachedBzlLoadValueAndDeps cachedBzlLoadValueAndDeps = visitedDepsInToplevelLoad.get(key);
+ if (cachedBzlLoadValueAndDeps == null) {
+ cachedBzlLoadValueAndDeps = selfInliningManager.bzlLoadValueCache.getIfPresent(key);
+ if (cachedBzlLoadValueAndDeps != null) {
+ cachedBzlLoadValueAndDeps.traverse(env::registerDependencies, visitedDepsInToplevelLoad);
}
}
- if (cachedStarlarkImportLookupValueAndDeps != null) {
- return cachedStarlarkImportLookupValueAndDeps;
+ if (cachedBzlLoadValueAndDeps != null) {
+ return cachedBzlLoadValueAndDeps;
}
// visitedNested is keyed on the SkyKey, not the label, because it's possible for distinct keys
@@ -243,17 +236,17 @@
// chunking information. It's unclear whether these particular cycles can arise in practice, but
// it doesn't hurt to be robust to future changes that may make that possible.
if (!visitedNested.add(key)) {
- ImmutableList<StarlarkImportLookupValue.Key> cycle =
+ ImmutableList<BzlLoadValue.Key> cycle =
CycleUtils.splitIntoPathAndChain(Predicates.equalTo(key), visitedNested).second;
- throw new StarlarkImportFailedException("Starlark import cycle: " + cycle);
+ throw new BzlLoadFailedException("Starlark load cycle: " + cycle);
}
- CachedStarlarkImportLookupValueAndDeps.Builder inlineCachedValueBuilder =
- selfInliningManager.cachedStarlarkImportLookupValueAndDepsBuilderFactory
- .newCachedStarlarkImportLookupValueAndDepsBuilder();
- // Use an instrumented Skyframe env to capture Skyframe deps in the
- // CachedStarlarkImportLookupValueAndDeps. This is transitive but doesn't include deps
- // underneath recursively loaded .bzls (the recursion uses the unwrapped original env).
+ CachedBzlLoadValueAndDeps.Builder inlineCachedValueBuilder =
+ selfInliningManager.cachedBzlLoadValueAndDepsBuilderFactory
+ .newCachedBzlLoadValueAndDepsBuilder();
+ // Use an instrumented Skyframe env to capture Skyframe deps in the CachedBzlLoadValueAndDeps.
+ // This is transitive but doesn't include deps underneath recursively loaded .bzls (the
+ // recursion uses the unwrapped original env).
Preconditions.checkState(
!(env instanceof RecordingSkyFunctionEnvironment),
"Found nested RecordingSkyFunctionEnvironment but it should have been stripped: %s",
@@ -264,23 +257,22 @@
inlineCachedValueBuilder::addDep,
inlineCachedValueBuilder::addDeps,
inlineCachedValueBuilder::noteException);
- StarlarkImportLookupValue value =
+ BzlLoadValue value =
computeInternal(
key,
recordingEnv,
new InliningState(visitedNested, inlineCachedValueBuilder, visitedDepsInToplevelLoad));
- // All imports traversed, this key can no longer be part of a cycle.
+ // All loads traversed, this key can no longer be part of a cycle.
Preconditions.checkState(visitedNested.remove(key), key);
if (value != null) {
inlineCachedValueBuilder.setValue(value);
inlineCachedValueBuilder.setKey(key);
- cachedStarlarkImportLookupValueAndDeps = inlineCachedValueBuilder.build();
- visitedDepsInToplevelLoad.put(key, cachedStarlarkImportLookupValueAndDeps);
- selfInliningManager.starlarkImportLookupValueCache.put(
- key, cachedStarlarkImportLookupValueAndDeps);
+ cachedBzlLoadValueAndDeps = inlineCachedValueBuilder.build();
+ visitedDepsInToplevelLoad.put(key, cachedBzlLoadValueAndDeps);
+ selfInliningManager.bzlLoadValueCache.put(key, cachedBzlLoadValueAndDeps);
}
- return cachedStarlarkImportLookupValueAndDeps;
+ return cachedBzlLoadValueAndDeps;
}
public void resetSelfInliningCache() {
@@ -289,7 +281,7 @@
private static ContainingPackageLookupValue getContainingPackageLookupValue(
Environment env, Label label)
- throws InconsistentFilesystemException, StarlarkImportFailedException, InterruptedException {
+ throws InconsistentFilesystemException, BzlLoadFailedException, InterruptedException {
PathFragment dir = Label.getContainingDirectory(label);
PackageIdentifier dirId =
PackageIdentifier.create(label.getPackageIdentifier().getRepository(), dir);
@@ -302,7 +294,7 @@
BuildFileNotFoundException.class,
InconsistentFilesystemException.class);
} catch (BuildFileNotFoundException e) {
- throw StarlarkImportFailedException.errorReadingFile(
+ throw BzlLoadFailedException.errorReadingFile(
label.toPathFragment(), new ErrorReadingStarlarkExtensionException(e));
}
if (containingPackageLookupValue == null) {
@@ -310,29 +302,26 @@
}
// Ensure the label doesn't cross package boundaries.
if (!containingPackageLookupValue.hasContainingPackage()) {
- throw StarlarkImportFailedException.noBuildFile(
+ throw BzlLoadFailedException.noBuildFile(
label, containingPackageLookupValue.getReasonForNoContainingPackage());
}
if (!containingPackageLookupValue
.getContainingPackageName()
.equals(label.getPackageIdentifier())) {
- throw StarlarkImportFailedException.labelCrossesPackageBoundary(
- label, containingPackageLookupValue);
+ throw BzlLoadFailedException.labelCrossesPackageBoundary(label, containingPackageLookupValue);
}
return containingPackageLookupValue;
}
private static class InliningState {
- private final Set<StarlarkImportLookupValue.Key> visitedNested;
- private final CachedStarlarkImportLookupValueAndDeps.Builder inlineCachedValueBuilder;
- private final Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- visitedDepsInToplevelLoad;
+ private final Set<BzlLoadValue.Key> visitedNested;
+ private final CachedBzlLoadValueAndDeps.Builder inlineCachedValueBuilder;
+ private final Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDepsInToplevelLoad;
private InliningState(
- Set<StarlarkImportLookupValue.Key> visitedNested,
- CachedStarlarkImportLookupValueAndDeps.Builder inlineCachedValueBuilder,
- Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- visitedDepsInToplevelLoad) {
+ Set<BzlLoadValue.Key> visitedNested,
+ CachedBzlLoadValueAndDeps.Builder inlineCachedValueBuilder,
+ Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDepsInToplevelLoad) {
this.visitedNested = visitedNested;
this.inlineCachedValueBuilder = inlineCachedValueBuilder;
this.visitedDepsInToplevelLoad = visitedDepsInToplevelLoad;
@@ -343,9 +332,9 @@
// exception. We are allowed to wrap the thrown exception and rethrow it for any calling functions
// to handle though.
@Nullable
- private StarlarkImportLookupValue computeInternal(
- StarlarkImportLookupValue.Key key, Environment env, @Nullable InliningState inliningState)
- throws InconsistentFilesystemException, StarlarkImportFailedException, InterruptedException {
+ private BzlLoadValue computeInternal(
+ BzlLoadValue.Key key, Environment env, @Nullable InliningState inliningState)
+ throws InconsistentFilesystemException, BzlLoadFailedException, InterruptedException {
Label label = key.getLabel();
PathFragment filePath = label.toPathFragment();
@@ -363,20 +352,18 @@
try {
astLookupValue = astFileLookupValueManager.getASTFileLookupValue(label, env);
} catch (ErrorReadingStarlarkExtensionException e) {
- throw StarlarkImportFailedException.errorReadingFile(filePath, e);
+ throw BzlLoadFailedException.errorReadingFile(filePath, e);
}
if (astLookupValue == null) {
return null;
}
- StarlarkImportLookupValue result = null;
+ BzlLoadValue result = null;
try {
result =
computeInternalWithAst(
key, filePath, starlarkSemantics, astLookupValue, env, inliningState);
- } catch (InconsistentFilesystemException
- | StarlarkImportFailedException
- | InterruptedException e) {
+ } catch (InconsistentFilesystemException | BzlLoadFailedException | InterruptedException e) {
astFileLookupValueManager.doneWithASTFileLookupValue(label);
throw e;
}
@@ -388,23 +375,23 @@
}
@Nullable
- private StarlarkImportLookupValue computeInternalWithAst(
- StarlarkImportLookupValue.Key key,
+ private BzlLoadValue computeInternalWithAst(
+ BzlLoadValue.Key key,
PathFragment filePath,
StarlarkSemantics starlarkSemantics,
ASTFileLookupValue astLookupValue,
Environment env,
@Nullable InliningState inliningState)
- throws InconsistentFilesystemException, StarlarkImportFailedException, InterruptedException {
+ throws InconsistentFilesystemException, BzlLoadFailedException, InterruptedException {
Label label = key.getLabel();
if (!astLookupValue.lookupSuccessful()) {
- // Starlark import files must exist.
- throw new StarlarkImportFailedException(astLookupValue.getError());
+ // Starlark code must exist.
+ throw new BzlLoadFailedException(astLookupValue.getError());
}
StarlarkFile file = astLookupValue.getAST();
if (!file.ok()) {
- throw StarlarkImportFailedException.skylarkErrors(filePath);
+ throw BzlLoadFailedException.skylarkErrors(filePath);
}
// Process the load statements in the file,
@@ -417,25 +404,25 @@
getLoadLabels(env.getListener(), file, label.getPackageIdentifier(), repoMapping);
if (loads == null) {
// malformed load statements
- throw StarlarkImportFailedException.skylarkErrors(filePath);
+ throw BzlLoadFailedException.skylarkErrors(filePath);
}
// Compute Skyframe key for each label in 'loads'.
- List<StarlarkImportLookupValue.Key> loadKeys = Lists.newArrayListWithExpectedSize(loads.size());
+ List<BzlLoadValue.Key> loadKeys = Lists.newArrayListWithExpectedSize(loads.size());
for (Pair<String, Label> load : loads) {
loadKeys.add(key.getKeyForLoad(load.second));
}
// Load .bzl modules in parallel.
- List<StarlarkImportLookupValue> starlarkImports =
+ List<BzlLoadValue> bzlLoads =
inliningState == null
- ? computeStarlarkImportsNoInlining(env, loadKeys, file.getStartLocation())
- : computeStarlarkImportsWithSelfInlining(env, loadKeys, label, inliningState);
- if (starlarkImports == null) {
+ ? computeBzlLoadsNoInlining(env, loadKeys, file.getStartLocation())
+ : computeBzlLoadsWithSelfInlining(env, loadKeys, label, inliningState);
+ if (bzlLoads == null) {
return null; // Skyframe deps unavailable
}
- // Process the loaded imports.
+ // Process the loaded modules.
//
// Compute a digest of the file itself plus the transitive hashes of the modules it directly
// loads. Loop iteration order matches the source order of load statements.
@@ -446,7 +433,7 @@
ImmutableList.builderWithExpectedSize(loads.size());
for (int i = 0; i < loads.size(); i++) {
String loadString = loads.get(i).first;
- StarlarkImportLookupValue v = starlarkImports.get(i);
+ BzlLoadValue v = bzlLoads.get(i);
loadedModules.put(loadString, v.getModule());
fileDependencies.add(v.getDependency());
fp.addBytes(v.getTransitiveDigest());
@@ -454,7 +441,7 @@
byte[] transitiveDigest = fp.digestAndReset();
// executeModule does not request values from the Environment. It may post events to the
- // Environment, but events do not matter when caching StarlarkImportLookupValues.
+ // Environment, but events do not matter when caching BzlLoadValues.
Module module =
executeModule(
file,
@@ -463,23 +450,22 @@
loadedModules,
starlarkSemantics,
env,
- /*inWorkspace=*/ key instanceof StarlarkImportLookupValue.WorkspaceBzlKey,
+ /*inWorkspace=*/ key instanceof BzlLoadValue.WorkspaceBzlKey,
repoMapping);
- StarlarkImportLookupValue result =
- new StarlarkImportLookupValue(
+ BzlLoadValue result =
+ new BzlLoadValue(
module, transitiveDigest, new StarlarkFileDependency(label, fileDependencies.build()));
return result;
}
private static ImmutableMap<RepositoryName, RepositoryName> getRepositoryMapping(
- StarlarkImportLookupValue.Key key, Environment env) throws InterruptedException {
+ BzlLoadValue.Key key, Environment env) throws InterruptedException {
Label enclosingFileLabel = key.getLabel();
ImmutableMap<RepositoryName, RepositoryName> repositoryMapping;
- if (key instanceof StarlarkImportLookupValue.WorkspaceBzlKey) {
+ if (key instanceof BzlLoadValue.WorkspaceBzlKey) {
// Still during workspace file evaluation
- StarlarkImportLookupValue.WorkspaceBzlKey workspaceBzlKey =
- (StarlarkImportLookupValue.WorkspaceBzlKey) key;
+ BzlLoadValue.WorkspaceBzlKey workspaceBzlKey = (BzlLoadValue.WorkspaceBzlKey) key;
if (workspaceBzlKey.getWorkspaceChunk() == 0) {
// There is no previous workspace chunk
repositoryMapping = ImmutableMap.of();
@@ -569,53 +555,48 @@
}
/**
- * Compute the StarlarkImportLookupValue for all given keys using vanilla Skyframe evaluation,
- * returning {@code null} if Skyframe deps were missing and have been requested.
+ * Compute the BzlLoadValue for all given keys using vanilla Skyframe evaluation, returning {@code
+ * null} if Skyframe deps were missing and have been requested.
*/
@Nullable
- private static List<StarlarkImportLookupValue> computeStarlarkImportsNoInlining(
- Environment env, List<StarlarkImportLookupValue.Key> keys, Location locationForErrors)
- throws StarlarkImportFailedException, InterruptedException {
- List<StarlarkImportLookupValue> starlarkImports =
- Lists.newArrayListWithExpectedSize(keys.size());
- Map<SkyKey, ValueOrException<StarlarkImportFailedException>> values =
- env.getValuesOrThrow(keys, StarlarkImportFailedException.class);
+ private static List<BzlLoadValue> computeBzlLoadsNoInlining(
+ Environment env, List<BzlLoadValue.Key> keys, Location locationForErrors)
+ throws BzlLoadFailedException, InterruptedException {
+ List<BzlLoadValue> bzlLoads = Lists.newArrayListWithExpectedSize(keys.size());
+ Map<SkyKey, ValueOrException<BzlLoadFailedException>> values =
+ env.getValuesOrThrow(keys, BzlLoadFailedException.class);
// Uses same order as load()s in the file. Order matters since we report the first error.
- for (StarlarkImportLookupValue.Key key : keys) {
+ for (BzlLoadValue.Key key : keys) {
try {
- starlarkImports.add((StarlarkImportLookupValue) values.get(key).get());
- } catch (StarlarkImportFailedException exn) {
- throw new StarlarkImportFailedException(
+ bzlLoads.add((BzlLoadValue) values.get(key).get());
+ } catch (BzlLoadFailedException exn) {
+ throw new BzlLoadFailedException(
"in " + locationForErrors.file() + ": " + exn.getMessage());
}
}
- return env.valuesMissing() ? null : starlarkImports;
+ return env.valuesMissing() ? null : bzlLoads;
}
/**
- * Compute the StarlarkImportLookupValue for all given keys by reusing this instance of the
- * StarlarkImportLookupFunction, bypassing traditional Skyframe evaluation, returning {@code null}
- * if Skyframe deps were missing and have been requested.
+ * Compute the BzlLoadValue for all given keys by reusing this instance of the BzlLoadFunction,
+ * bypassing traditional Skyframe evaluation, returning {@code null} if Skyframe deps were missing
+ * and have been requested.
*/
@Nullable
- private List<StarlarkImportLookupValue> computeStarlarkImportsWithSelfInlining(
- Environment env,
- List<StarlarkImportLookupValue.Key> keys,
- Label fileLabel,
- InliningState inliningState)
- throws InterruptedException, StarlarkImportFailedException, InconsistentFilesystemException {
+ private List<BzlLoadValue> computeBzlLoadsWithSelfInlining(
+ Environment env, List<BzlLoadValue.Key> keys, Label fileLabel, InliningState inliningState)
+ throws InterruptedException, BzlLoadFailedException, InconsistentFilesystemException {
Preconditions.checkState(
env instanceof RecordingSkyFunctionEnvironment,
- "Expected to be recording dep requests when inlining StarlarkImportLookupFunction: %s",
+ "Expected to be recording dep requests when inlining BzlLoadFunction: %s",
fileLabel);
Environment strippedEnv = ((RecordingSkyFunctionEnvironment) env).getDelegate();
- List<StarlarkImportLookupValue> starlarkImports =
- Lists.newArrayListWithExpectedSize(keys.size());
+ List<BzlLoadValue> bzlLoads = Lists.newArrayListWithExpectedSize(keys.size());
Exception deferredException = null;
boolean valuesMissing = false;
- // NOTE: Iterating over imports in the order listed in the file.
- for (StarlarkImportLookupValue.Key key : keys) {
- CachedStarlarkImportLookupValueAndDeps cachedValue;
+ // NOTE: Iterating over loads in the order listed in the file.
+ for (BzlLoadValue.Key key : keys) {
+ CachedBzlLoadValueAndDeps cachedValue;
try {
cachedValue =
computeWithSelfInlineCallsInternal(
@@ -623,33 +604,33 @@
strippedEnv,
inliningState.visitedNested,
inliningState.visitedDepsInToplevelLoad);
- } catch (StarlarkImportFailedException | InconsistentFilesystemException e) {
+ } catch (BzlLoadFailedException | InconsistentFilesystemException e) {
// For determinism's sake while inlining, preserve the first exception and continue to run
- // subsequently listed imports to completion/exception, loading all transitive deps anyway.
+ // subsequently listed loads to completion/exception, loading all transitive deps anyway.
deferredException = MoreObjects.firstNonNull(deferredException, e);
continue;
}
if (cachedValue == null) {
- Preconditions.checkState(env.valuesMissing(), "no starlark import value for %s", key);
+ Preconditions.checkState(env.valuesMissing(), "no starlark load value for %s", key);
// We continue making inline calls even if some requested values are missing, to maximize
// the number of dependent (non-inlined) SkyFunctions that are requested, thus avoiding a
// quadratic number of restarts.
valuesMissing = true;
} else {
- starlarkImports.add(cachedValue.getValue());
+ bzlLoads.add(cachedValue.getValue());
inliningState.inlineCachedValueBuilder.addTransitiveDeps(cachedValue);
}
}
if (deferredException != null) {
- Throwables.throwIfInstanceOf(deferredException, StarlarkImportFailedException.class);
+ Throwables.throwIfInstanceOf(deferredException, BzlLoadFailedException.class);
Throwables.throwIfInstanceOf(deferredException, InconsistentFilesystemException.class);
throw new IllegalStateException(
"caught a checked exception of unexpected type", deferredException);
}
- return valuesMissing ? null : starlarkImports;
+ return valuesMissing ? null : bzlLoads;
}
- /** Executes the .bzl file defining the module to be imported. */
+ /** Executes the .bzl file defining the module to be loaded. */
private Module executeModule(
StarlarkFile file,
Label label,
@@ -659,14 +640,14 @@
Environment env,
boolean inWorkspace,
ImmutableMap<RepositoryName, RepositoryName> repositoryMapping)
- throws StarlarkImportFailedException, InterruptedException {
+ throws BzlLoadFailedException, InterruptedException {
// set up .bzl predeclared environment
Map<String, Object> predeclared = new HashMap<>(ruleClassProvider.getEnvironment());
predeclared.put("native", packageFactory.getNativeModule(inWorkspace));
Module module = Module.withPredeclared(starlarkSemantics, predeclared);
module.setClientData(BazelModuleContext.create(label, transitiveDigest));
- try (Mutability mu = Mutability.create("importing", label)) {
+ try (Mutability mu = Mutability.create("loading", label)) {
StarlarkThread thread = new StarlarkThread(mu, starlarkSemantics);
thread.setLoader(loadedModules::get);
StoredEventHandler eventHandler = new StoredEventHandler();
@@ -679,7 +660,7 @@
env.getListener().post(post);
}
if (eventHandler.hasErrors()) {
- throw StarlarkImportFailedException.errors(label.toPathFragment());
+ throw BzlLoadFailedException.errors(label.toPathFragment());
}
return module;
}
@@ -721,41 +702,38 @@
return null;
}
- static final class StarlarkImportFailedException extends Exception
- implements SaneAnalysisException {
+ static final class BzlLoadFailedException extends Exception implements SaneAnalysisException {
private final Transience transience;
- private StarlarkImportFailedException(String errorMessage) {
+ private BzlLoadFailedException(String errorMessage) {
super(errorMessage);
this.transience = Transience.PERSISTENT;
}
- private StarlarkImportFailedException(
- String errorMessage, Exception cause, Transience transience) {
+ private BzlLoadFailedException(String errorMessage, Exception cause, Transience transience) {
super(errorMessage, cause);
this.transience = transience;
}
- static StarlarkImportFailedException errors(PathFragment file) {
- return new StarlarkImportFailedException(
- String.format("Extension file '%s' has errors", file));
+ static BzlLoadFailedException errors(PathFragment file) {
+ return new BzlLoadFailedException(String.format("Extension file '%s' has errors", file));
}
- static StarlarkImportFailedException errorReadingFile(
+ static BzlLoadFailedException errorReadingFile(
PathFragment file, ErrorReadingStarlarkExtensionException cause) {
- return new StarlarkImportFailedException(
+ return new BzlLoadFailedException(
String.format(
"Encountered error while reading extension file '%s': %s", file, cause.getMessage()),
cause,
cause.getTransience());
}
- static StarlarkImportFailedException noBuildFile(Label file, @Nullable String reason) {
+ static BzlLoadFailedException noBuildFile(Label file, @Nullable String reason) {
if (reason != null) {
- return new StarlarkImportFailedException(
+ return new BzlLoadFailedException(
String.format("Unable to find package for %s: %s.", file, reason));
}
- return new StarlarkImportFailedException(
+ return new BzlLoadFailedException(
String.format(
"Every .bzl file must have a corresponding package, but '%s' does not have one."
+ " Please create a BUILD file in the same or any parent directory. Note that"
@@ -763,9 +741,9 @@
file));
}
- static StarlarkImportFailedException labelCrossesPackageBoundary(
+ static BzlLoadFailedException labelCrossesPackageBoundary(
Label label, ContainingPackageLookupValue containingPackageLookupValue) {
- return new StarlarkImportFailedException(
+ return new BzlLoadFailedException(
ContainingPackageLookupValue.getErrorMessageForLabelCrossingPackageBoundary(
// We don't actually know the proper Root to pass in here (since we don't e.g. know
// the root of the bzl/BUILD file that is trying to load 'label'). Therefore we just
@@ -776,8 +754,8 @@
containingPackageLookupValue));
}
- static StarlarkImportFailedException skylarkErrors(PathFragment file) {
- return new StarlarkImportFailedException(String.format("Extension '%s' has errors", file));
+ static BzlLoadFailedException skylarkErrors(PathFragment file) {
+ return new BzlLoadFailedException(String.format("Extension '%s' has errors", file));
}
}
@@ -816,9 +794,8 @@
private final RuleClassProvider ruleClassProvider;
private final DigestHashFunction digestHashFunction;
// We keep a cache of ASTFileLookupValues that have been computed but whose corresponding
- // StarlarkImportLookupValue has not yet completed. This avoids repeating the ASTFileLookupValue
- // work in case of Skyframe restarts. (If we weren't inlining, Skyframe would cache this for
- // us.)
+ // BzlLoadValue has not yet completed. This avoids repeating the ASTFileLookupValue work in case
+ // of Skyframe restarts. (If we weren't inlining, Skyframe would cache this for us.)
private final Cache<Label, ASTFileLookupValue> astFileLookupValueCache;
private InliningAndCachingASTFileLookupValueManager(
@@ -854,45 +831,40 @@
}
private static class SelfInliningManager {
- private final int starlarkImportLookupValueCacheSize;
- private Cache<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- starlarkImportLookupValueCache;
- private CachedStarlarkImportLookupValueAndDepsBuilderFactory
- cachedStarlarkImportLookupValueAndDepsBuilderFactory =
- new CachedStarlarkImportLookupValueAndDepsBuilderFactory();
+ private final int bzlLoadValueCacheSize;
+ private Cache<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> bzlLoadValueCache;
+ private CachedBzlLoadValueAndDepsBuilderFactory cachedBzlLoadValueAndDepsBuilderFactory =
+ new CachedBzlLoadValueAndDepsBuilderFactory();
- private SelfInliningManager(int starlarkImportLookupValueCacheSize) {
- this.starlarkImportLookupValueCacheSize = starlarkImportLookupValueCacheSize;
+ private SelfInliningManager(int bzlLoadValueCacheSize) {
+ this.bzlLoadValueCacheSize = bzlLoadValueCacheSize;
}
private void reset() {
- if (starlarkImportLookupValueCache != null) {
+ if (bzlLoadValueCache != null) {
logger.atInfo().log(
- "Starlark inlining cache stats from earlier build: "
- + starlarkImportLookupValueCache.stats());
+ "Starlark inlining cache stats from earlier build: " + bzlLoadValueCache.stats());
}
- cachedStarlarkImportLookupValueAndDepsBuilderFactory =
- new CachedStarlarkImportLookupValueAndDepsBuilderFactory();
+ cachedBzlLoadValueAndDepsBuilderFactory = new CachedBzlLoadValueAndDepsBuilderFactory();
Preconditions.checkState(
- starlarkImportLookupValueCacheSize >= 0,
+ bzlLoadValueCacheSize >= 0,
"Expected positive Starlark cache size if caching. %s",
- starlarkImportLookupValueCacheSize);
- starlarkImportLookupValueCache =
+ bzlLoadValueCacheSize);
+ bzlLoadValueCache =
CacheBuilder.newBuilder()
.concurrencyLevel(BlazeInterners.concurrencyLevel())
- .maximumSize(starlarkImportLookupValueCacheSize)
+ .maximumSize(bzlLoadValueCacheSize)
.recordStats()
.build();
}
}
- private static final class StarlarkImportLookupFunctionException extends SkyFunctionException {
- private StarlarkImportLookupFunctionException(StarlarkImportFailedException cause) {
+ private static final class BzlLoadFunctionException extends SkyFunctionException {
+ private BzlLoadFunctionException(BzlLoadFailedException cause) {
super(cause, cause.transience);
}
- private StarlarkImportLookupFunctionException(InconsistentFilesystemException e,
- Transience transience) {
+ private BzlLoadFunctionException(InconsistentFilesystemException e, Transience transience) {
super(e, transience);
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadValue.java
similarity index 92%
rename from src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupValue.java
rename to src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadValue.java
index 498ec5c..7bcbc6d 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkImportLookupValue.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/BzlLoadValue.java
@@ -28,11 +28,11 @@
import java.util.Objects;
/**
- * A value that represents a Starlark import lookup result. The lookup value corresponds to exactly
- * one Starlark file, identified by an absolute {@link Label} {@link SkyKey} argument. The Label
- * should not reference the special {@code external} package.
+ * A value that represents a Starlark load result. The lookup value corresponds to exactly one
+ * Starlark file, identified by an absolute {@link Label} {@link SkyKey} argument. The Label should
+ * not reference the special {@code external} package.
*/
-public class StarlarkImportLookupValue implements SkyValue {
+public class BzlLoadValue implements SkyValue {
private final Module module; // .bzl module
private final byte[] transitiveDigest; // of .bzl file and load dependencies
@@ -45,8 +45,7 @@
private final StarlarkFileDependency dependency;
@VisibleForTesting
- public StarlarkImportLookupValue(
- Module module, byte[] transitiveDigest, StarlarkFileDependency dependency) {
+ public BzlLoadValue(Module module, byte[] transitiveDigest, StarlarkFileDependency dependency) {
this.module = Preconditions.checkNotNull(module);
this.transitiveDigest = Preconditions.checkNotNull(transitiveDigest);
this.dependency = Preconditions.checkNotNull(dependency);
@@ -62,14 +61,14 @@
return transitiveDigest;
}
- /** Returns the immediate Starlark file dependency corresponding to this import lookup value. */
+ /** Returns the immediate Starlark file dependency corresponding to this load value. */
public StarlarkFileDependency getDependency() {
return dependency;
}
private static final Interner<Key> keyInterner = BlazeInterners.newWeakInterner();
- /** SkyKey for a Starlark import. */
+ /** SkyKey for a Starlark load. */
abstract static class Key implements SkyKey {
/** Returns the label of the .bzl file to be loaded. */
@@ -87,7 +86,7 @@
@Override
public SkyFunctionName functionName() {
- return SkyFunctions.STARLARK_IMPORTS_LOOKUP;
+ return SkyFunctions.BZL_LOAD;
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDeps.java b/src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDeps.java
similarity index 70%
rename from src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDeps.java
rename to src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDeps.java
index afc1180..7c9b469 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDeps.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDeps.java
@@ -25,17 +25,17 @@
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
-class CachedStarlarkImportLookupValueAndDeps {
- private final StarlarkImportLookupValue.Key key;
- private final StarlarkImportLookupValue value;
+class CachedBzlLoadValueAndDeps {
+ private final BzlLoadValue.Key key;
+ private final BzlLoadValue value;
private final ImmutableList<Iterable<SkyKey>> directDeps;
- private final ImmutableList<CachedStarlarkImportLookupValueAndDeps> transitiveDeps;
+ private final ImmutableList<CachedBzlLoadValueAndDeps> transitiveDeps;
- private CachedStarlarkImportLookupValueAndDeps(
- StarlarkImportLookupValue.Key key,
- StarlarkImportLookupValue value,
+ private CachedBzlLoadValueAndDeps(
+ BzlLoadValue.Key key,
+ BzlLoadValue value,
ImmutableList<Iterable<SkyKey>> directDeps,
- ImmutableList<CachedStarlarkImportLookupValueAndDeps> transitiveDeps) {
+ ImmutableList<CachedBzlLoadValueAndDeps> transitiveDeps) {
this.key = key;
this.value = value;
this.directDeps = directDeps;
@@ -44,12 +44,12 @@
void traverse(
DepGroupConsumer depGroupConsumer,
- Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps> visitedDeps)
+ Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDeps)
throws InterruptedException {
for (Iterable<SkyKey> directDepGroup : directDeps) {
depGroupConsumer.accept(directDepGroup);
}
- for (CachedStarlarkImportLookupValueAndDeps indirectDeps : transitiveDeps) {
+ for (CachedBzlLoadValueAndDeps indirectDeps : transitiveDeps) {
if (!visitedDeps.containsKey(indirectDeps.key)) {
visitedDeps.put(indirectDeps.key, indirectDeps);
indirectDeps.traverse(depGroupConsumer, visitedDeps);
@@ -57,16 +57,16 @@
}
}
- StarlarkImportLookupValue getValue() {
+ BzlLoadValue getValue() {
return value;
}
@Override
public boolean equals(Object obj) {
- if (obj instanceof CachedStarlarkImportLookupValueAndDeps) {
+ if (obj instanceof CachedBzlLoadValueAndDeps) {
// With the interner, force there to be exactly one cached value per key at any given point
// in time.
- return this.key.equals(((CachedStarlarkImportLookupValueAndDeps) obj).key);
+ return this.key.equals(((CachedBzlLoadValueAndDeps) obj).key);
}
return false;
}
@@ -82,16 +82,16 @@
}
static class Builder {
- Builder(Interner<CachedStarlarkImportLookupValueAndDeps> interner) {
+ Builder(Interner<CachedBzlLoadValueAndDeps> interner) {
this.interner = interner;
}
- private final Interner<CachedStarlarkImportLookupValueAndDeps> interner;
+ private final Interner<CachedBzlLoadValueAndDeps> interner;
private final List<Iterable<SkyKey>> directDeps = new ArrayList<>();
- private final List<CachedStarlarkImportLookupValueAndDeps> transitiveDeps = new ArrayList<>();
+ private final List<CachedBzlLoadValueAndDeps> transitiveDeps = new ArrayList<>();
private final AtomicReference<Exception> exceptionSeen = new AtomicReference<>(null);
- private StarlarkImportLookupValue value;
- private StarlarkImportLookupValue.Key key;
+ private BzlLoadValue value;
+ private BzlLoadValue.Key key;
@CanIgnoreReturnValue
Builder addDep(SkyKey key) {
@@ -116,36 +116,36 @@
}
@CanIgnoreReturnValue
- Builder addTransitiveDeps(CachedStarlarkImportLookupValueAndDeps transitiveDeps) {
+ Builder addTransitiveDeps(CachedBzlLoadValueAndDeps transitiveDeps) {
this.transitiveDeps.add(transitiveDeps);
return this;
}
@CanIgnoreReturnValue
- Builder setValue(StarlarkImportLookupValue value) {
+ Builder setValue(BzlLoadValue value) {
this.value = value;
return this;
}
@CanIgnoreReturnValue
- Builder setKey(StarlarkImportLookupValue.Key key) {
+ Builder setKey(BzlLoadValue.Key key) {
this.key = key;
return this;
}
- CachedStarlarkImportLookupValueAndDeps build() {
- // We expect that we don't handle any exceptions in StarlarkLookupImportFunction directly.
+ CachedBzlLoadValueAndDeps build() {
+ // We expect that we don't handle any exceptions in BzlLoadFunction directly.
Preconditions.checkState(exceptionSeen.get() == null, "Caching a value in error?: %s", this);
Preconditions.checkNotNull(value, "Expected value to be set: %s", this);
Preconditions.checkNotNull(key, "Expected key to be set: %s", this);
return interner.intern(
- new CachedStarlarkImportLookupValueAndDeps(
+ new CachedBzlLoadValueAndDeps(
key, value, ImmutableList.copyOf(directDeps), ImmutableList.copyOf(transitiveDeps)));
}
@Override
public String toString() {
- return MoreObjects.toStringHelper(CachedStarlarkImportLookupValueAndDeps.Builder.class)
+ return MoreObjects.toStringHelper(CachedBzlLoadValueAndDeps.Builder.class)
.add("key", key)
.add("value", value)
.add("directDeps", directDeps)
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDepsBuilderFactory.java b/src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDepsBuilderFactory.java
similarity index 64%
rename from src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDepsBuilderFactory.java
rename to src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDepsBuilderFactory.java
index 5272424..77fc055 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/CachedStarlarkImportLookupValueAndDepsBuilderFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/CachedBzlLoadValueAndDepsBuilderFactory.java
@@ -17,13 +17,11 @@
import com.google.common.collect.Interner;
import com.google.devtools.build.lib.concurrent.BlazeInterners;
-/** Factory class for producing CachedStarlarkImportLookupValueAndDeps. */
-public class CachedStarlarkImportLookupValueAndDepsBuilderFactory {
- private final Interner<CachedStarlarkImportLookupValueAndDeps> interner =
- BlazeInterners.newWeakInterner();
+/** Factory class for producing CachedBzlLoadValueAndDeps. */
+public class CachedBzlLoadValueAndDepsBuilderFactory {
+ private final Interner<CachedBzlLoadValueAndDeps> interner = BlazeInterners.newWeakInterner();
- CachedStarlarkImportLookupValueAndDeps.Builder
- newCachedStarlarkImportLookupValueAndDepsBuilder() {
- return new CachedStarlarkImportLookupValueAndDeps.Builder(interner);
+ CachedBzlLoadValueAndDeps.Builder newCachedBzlLoadValueAndDepsBuilder() {
+ return new CachedBzlLoadValueAndDeps.Builder(interner);
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
index 266be0c..6c81c51d 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
@@ -53,8 +53,8 @@
import com.google.devtools.build.lib.profiler.SilentCloseable;
import com.google.devtools.build.lib.repository.ExternalPackageHelper;
import com.google.devtools.build.lib.rules.repository.WorkspaceFileHelper;
+import com.google.devtools.build.lib.skyframe.BzlLoadFunction.BzlLoadFailedException;
import com.google.devtools.build.lib.skyframe.GlobValue.InvalidGlobPatternException;
-import com.google.devtools.build.lib.skyframe.StarlarkImportLookupFunction.StarlarkImportFailedException;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.FileOptions;
import com.google.devtools.build.lib.syntax.Location;
@@ -106,7 +106,7 @@
private final ExternalPackageHelper externalPackageHelper;
// Not final only for testing.
- @Nullable private StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining;
+ @Nullable private BzlLoadFunction bzlLoadFunctionForInlining;
private final ActionOnIOExceptionReadingBuildFile actionOnIOExceptionReadingBuildFile;
@@ -119,12 +119,12 @@
Cache<PackageIdentifier, LoadedPackageCacheEntry> packageFunctionCache,
Cache<PackageIdentifier, StarlarkFile> fileSyntaxCache,
AtomicInteger numPackagesLoaded,
- @Nullable StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining,
+ @Nullable BzlLoadFunction bzlLoadFunctionForInlining,
@Nullable PackageProgressReceiver packageProgress,
ActionOnIOExceptionReadingBuildFile actionOnIOExceptionReadingBuildFile,
IncrementalityIntent incrementalityIntent,
ExternalPackageHelper externalPackageHelper) {
- this.starlarkImportLookupFunctionForInlining = starlarkImportLookupFunctionForInlining;
+ this.bzlLoadFunctionForInlining = bzlLoadFunctionForInlining;
// Can be null in tests.
this.preludeLabel = packageFactory == null
? null
@@ -149,7 +149,7 @@
Cache<PackageIdentifier, LoadedPackageCacheEntry> packageFunctionCache,
Cache<PackageIdentifier, StarlarkFile> fileSyntaxCache,
AtomicInteger numPackagesLoaded,
- @Nullable StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining,
+ @Nullable BzlLoadFunction bzlLoadFunctionForInlining,
ExternalPackageHelper externalPackageHelper) {
this(
packageFactory,
@@ -158,16 +158,15 @@
packageFunctionCache,
fileSyntaxCache,
numPackagesLoaded,
- starlarkImportLookupFunctionForInlining,
+ bzlLoadFunctionForInlining,
/*packageProgress=*/ null,
ActionOnIOExceptionReadingBuildFile.UseOriginalIOException.INSTANCE,
IncrementalityIntent.INCREMENTAL,
externalPackageHelper);
}
- public void setStarlarkImportLookupFunctionForInliningForTesting(
- StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining) {
- this.starlarkImportLookupFunctionForInlining = starlarkImportLookupFunctionForInlining;
+ public void setBzlLoadFunctionForInliningForTesting(BzlLoadFunction bzlLoadFunctionForInlining) {
+ this.bzlLoadFunctionForInlining = bzlLoadFunctionForInlining;
}
/**
@@ -319,8 +318,8 @@
workspaceKey,
IOException.class,
EvalException.class,
- StarlarkImportFailedException.class);
- } catch (IOException | EvalException | StarlarkImportFailedException e) {
+ BzlLoadFailedException.class);
+ } catch (IOException | EvalException | BzlLoadFailedException e) {
throw new PackageFunctionException(
new NoSuchPackageException(
LabelConstants.EXTERNAL_PACKAGE_IDENTIFIER,
@@ -572,8 +571,8 @@
return buildFileValue;
}
- private static BuildFileContainsErrorsException makeStarlarkImportFailedException(
- PackageIdentifier packageId, StarlarkImportFailedException e) {
+ private static BuildFileContainsErrorsException makeBzlLoadFailedException(
+ PackageIdentifier packageId, BzlLoadFailedException e) {
Throwable rootCause = Throwables.getRootCause(e);
return (rootCause instanceof IOException)
? new BuildFileContainsErrorsException(packageId, e.getMessage(), (IOException) rootCause)
@@ -585,52 +584,51 @@
* null.
*/
@Nullable
- static StarlarkImportResult fetchImportsFromBuildFile(
+ static BzlLoadResult fetchLoadsFromBuildFile(
RootedPath buildFilePath,
PackageIdentifier packageId,
ImmutableMap<RepositoryName, RepositoryName> repoMapping,
StarlarkFile file,
int workspaceChunk,
Environment env,
- StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining)
+ BzlLoadFunction bzlLoadFunctionForInlining)
throws NoSuchPackageException, InterruptedException {
Preconditions.checkArgument(!packageId.getRepository().isDefault());
// Parse the labels in the file's load statements.
List<Pair<String, Label>> loads =
- StarlarkImportLookupFunction.getLoadLabels(env.getListener(), file, packageId, repoMapping);
+ BzlLoadFunction.getLoadLabels(env.getListener(), file, packageId, repoMapping);
if (loads == null) {
throw new BuildFileContainsErrorsException(packageId, "malformed load statements");
}
// Compute Skyframe key for each label in 'loads'.
- List<StarlarkImportLookupValue.Key> keys = Lists.newArrayListWithExpectedSize(loads.size());
+ List<BzlLoadValue.Key> keys = Lists.newArrayListWithExpectedSize(loads.size());
boolean inWorkspace =
WorkspaceFileHelper.endsWithWorkspaceFileName(buildFilePath.getRootRelativePath());
for (Pair<String, Label> load : loads) {
Label bzlLabel = load.second;
if (inWorkspace) {
int originalChunk = getOriginalWorkspaceChunk(env, buildFilePath, workspaceChunk, bzlLabel);
- keys.add(StarlarkImportLookupValue.workspaceBzlKey(bzlLabel, originalChunk, buildFilePath));
+ keys.add(BzlLoadValue.workspaceBzlKey(bzlLabel, originalChunk, buildFilePath));
} else {
- keys.add(StarlarkImportLookupValue.packageBzlKey(bzlLabel));
+ keys.add(BzlLoadValue.packageBzlKey(bzlLabel));
}
}
// Load .bzl modules in parallel.
- List<StarlarkImportLookupValue> starlarkImports;
+ List<BzlLoadValue> bzlLoads;
try {
- starlarkImports =
- starlarkImportLookupFunctionForInlining == null
- ? computeStarlarkImportsNoInlining(env, keys)
- : computeStarlarkImportsWithInlining(
- env, keys, starlarkImportLookupFunctionForInlining);
- } catch (StarlarkImportFailedException e) {
- throw makeStarlarkImportFailedException(packageId, e);
+ bzlLoads =
+ bzlLoadFunctionForInlining == null
+ ? computeBzlLoadsNoInlining(env, keys)
+ : computeBzlLoadsWithInlining(env, keys, bzlLoadFunctionForInlining);
+ } catch (BzlLoadFailedException e) {
+ throw makeBzlLoadFailedException(packageId, e);
} catch (InconsistentFilesystemException e) {
throw new NoSuchPackageException(packageId, e.getMessage(), e);
}
- if (starlarkImports == null) {
+ if (bzlLoads == null) {
return null; // Skyframe deps unavailable
}
@@ -639,89 +637,83 @@
ImmutableList.Builder<StarlarkFileDependency> fileDependencies = ImmutableList.builder();
for (int i = 0; i < loads.size(); i++) {
String loadString = loads.get(i).first;
- StarlarkImportLookupValue v = starlarkImports.get(i);
+ BzlLoadValue v = bzlLoads.get(i);
loadedModules.put(loadString, v.getModule());
fileDependencies.add(v.getDependency());
}
- return new StarlarkImportResult(
- loadedModules, transitiveClosureOfLabels(fileDependencies.build()));
+ return new BzlLoadResult(loadedModules, transitiveClosureOfLabels(fileDependencies.build()));
}
/**
- * Compute the StarlarkImportLookupValue for all given keys using vanilla Skyframe evaluation,
- * returning {@code null} if Skyframe deps were missing and have been requested.
- */
- @Nullable
- private static List<StarlarkImportLookupValue> computeStarlarkImportsNoInlining(
- Environment env, List<StarlarkImportLookupValue.Key> keys)
- throws InterruptedException, StarlarkImportFailedException, InconsistentFilesystemException {
- List<StarlarkImportLookupValue> starlarkImports =
- Lists.newArrayListWithExpectedSize(keys.size());
- Map<SkyKey, ValueOrException2<StarlarkImportFailedException, InconsistentFilesystemException>>
- skylarkLookupResults =
- env.getValuesOrThrow(
- keys, StarlarkImportFailedException.class, InconsistentFilesystemException.class);
- for (StarlarkImportLookupValue.Key key : keys) {
- starlarkImports.add((StarlarkImportLookupValue) skylarkLookupResults.get(key).get());
- }
- return env.valuesMissing() ? null : starlarkImports;
- }
-
- /**
- * Compute the StarlarkImportLookupValue for all given keys by "inlining" the
- * StarlarkImportLookupFunction and bypassing traditional Skyframe evaluation, returning {@code
+ * Compute the BzlLoadValue for all given keys using vanilla Skyframe evaluation, returning {@code
* null} if Skyframe deps were missing and have been requested.
*/
@Nullable
- private static List<StarlarkImportLookupValue> computeStarlarkImportsWithInlining(
- Environment env,
- List<StarlarkImportLookupValue.Key> keys,
- StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining)
- throws InterruptedException, StarlarkImportFailedException, InconsistentFilesystemException {
- List<StarlarkImportLookupValue> starlarkImports =
- Lists.newArrayListWithExpectedSize(keys.size());
+ private static List<BzlLoadValue> computeBzlLoadsNoInlining(
+ Environment env, List<BzlLoadValue.Key> keys)
+ throws InterruptedException, BzlLoadFailedException, InconsistentFilesystemException {
+ List<BzlLoadValue> bzlLoads = Lists.newArrayListWithExpectedSize(keys.size());
+ Map<SkyKey, ValueOrException2<BzlLoadFailedException, InconsistentFilesystemException>>
+ skylarkLookupResults =
+ env.getValuesOrThrow(
+ keys, BzlLoadFailedException.class, InconsistentFilesystemException.class);
+ for (BzlLoadValue.Key key : keys) {
+ bzlLoads.add((BzlLoadValue) skylarkLookupResults.get(key).get());
+ }
+ return env.valuesMissing() ? null : bzlLoads;
+ }
+
+ /**
+ * Compute the BzlLoadValue for all given keys by "inlining" the BzlLoadFunction and bypassing
+ * traditional Skyframe evaluation, returning {@code null} if Skyframe deps were missing and have
+ * been requested.
+ */
+ @Nullable
+ private static List<BzlLoadValue> computeBzlLoadsWithInlining(
+ Environment env, List<BzlLoadValue.Key> keys, BzlLoadFunction bzlLoadFunctionForInlining)
+ throws InterruptedException, BzlLoadFailedException, InconsistentFilesystemException {
+ List<BzlLoadValue> bzlLoads = Lists.newArrayListWithExpectedSize(keys.size());
Exception deferredException = null;
boolean valuesMissing = false;
- // Compute StarlarkImportLookupValue for each key, sharing this map as one big cache. This
- // ensures that each .bzl is loaded only once, regardless of diamond dependencies. (Multiple
- // loads of the same .bzl would screw up identity equality of some Starlark symbols.)
- Map<StarlarkImportLookupValue.Key, CachedStarlarkImportLookupValueAndDeps>
- visitedDepsInToplevelLoad = new HashMap<>();
- for (StarlarkImportLookupValue.Key key : keys) {
+ // Compute BzlLoadValue for each key, sharing this map as one big cache. This ensures that each
+ // .bzl is loaded only once, regardless of diamond dependencies. (Multiple loads of the same
+ // .bzl would screw up identity equality of some Starlark symbols -- see comments in
+ // BzlLoadFunction.)
+ Map<BzlLoadValue.Key, CachedBzlLoadValueAndDeps> visitedDepsInToplevelLoad = new HashMap<>();
+ for (BzlLoadValue.Key key : keys) {
SkyValue skyValue;
try {
// Will complete right away if it's already cached in visitedDepsInToplevelLoad.
skyValue =
- starlarkImportLookupFunctionForInlining
- .computeWithSelfInlineCallsForPackageAndWorkspaceNodes(
- key, env, visitedDepsInToplevelLoad);
- } catch (StarlarkImportFailedException | InconsistentFilesystemException e) {
+ bzlLoadFunctionForInlining.computeWithSelfInlineCallsForPackageAndWorkspaceNodes(
+ key, env, visitedDepsInToplevelLoad);
+ } catch (BzlLoadFailedException | InconsistentFilesystemException e) {
// For determinism's sake while inlining, preserve the first exception and continue to run
- // subsequently listed imports to completion/exception, loading all transitive deps anyway.
+ // subsequently listed loads to completion/exception, loading all transitive deps anyway.
deferredException = MoreObjects.firstNonNull(deferredException, e);
continue;
}
if (skyValue == null) {
- Preconditions.checkState(env.valuesMissing(), "no starlark import value for %s", key);
+ Preconditions.checkState(env.valuesMissing(), "no starlark load value for %s", key);
// We continue making inline calls even if some requested values are missing, to
// maximize the number of dependent (non-inlined) SkyFunctions that are requested, thus
// avoiding a quadratic number of restarts.
valuesMissing = true;
} else {
- starlarkImports.add((StarlarkImportLookupValue) skyValue);
+ bzlLoads.add((BzlLoadValue) skyValue);
}
}
if (deferredException != null) {
- Throwables.throwIfInstanceOf(deferredException, StarlarkImportFailedException.class);
+ Throwables.throwIfInstanceOf(deferredException, BzlLoadFailedException.class);
Throwables.throwIfInstanceOf(deferredException, InconsistentFilesystemException.class);
throw new IllegalStateException(
"caught a checked exception of unexpected type", deferredException);
}
- return valuesMissing ? null : starlarkImports;
+ return valuesMissing ? null : bzlLoads;
}
private static int getOriginalWorkspaceChunk(
- Environment env, RootedPath workspacePath, int workspaceChunk, Label importLabel)
+ Environment env, RootedPath workspacePath, int workspaceChunk, Label loadLabel)
throws InterruptedException {
if (workspaceChunk < 1) {
return workspaceChunk;
@@ -731,9 +723,9 @@
// for nullness
SkyKey workspaceFileKey = WorkspaceFileValue.key(workspacePath, workspaceChunk - 1);
WorkspaceFileValue workspaceFileValue = (WorkspaceFileValue) env.getValue(workspaceFileKey);
- ImmutableMap<String, Integer> importToChunkMap = workspaceFileValue.getImportToChunkMap();
- String importString = importLabel.toString();
- return importToChunkMap.getOrDefault(importString, workspaceChunk);
+ ImmutableMap<String, Integer> loadToChunkMap = workspaceFileValue.getLoadToChunkMap();
+ String loadString = loadLabel.toString();
+ return loadToChunkMap.getOrDefault(loadString, workspaceChunk);
}
private static ImmutableList<Label> transitiveClosureOfLabels(
@@ -1206,24 +1198,24 @@
file = StarlarkFile.parseWithPrelude(input, preludeStatements, options);
fileSyntaxCache.put(packageId, file);
}
- StarlarkImportResult importResult;
+ BzlLoadResult loadResult;
try {
- importResult =
- fetchImportsFromBuildFile(
+ loadResult =
+ fetchLoadsFromBuildFile(
buildFilePath,
packageId,
repositoryMapping,
file,
/* workspaceChunk = */ -1,
env,
- starlarkImportLookupFunctionForInlining);
+ bzlLoadFunctionForInlining);
} catch (NoSuchPackageException e) {
throw new PackageFunctionException(e, Transience.PERSISTENT);
} catch (InterruptedException e) {
fileSyntaxCache.invalidate(packageId);
throw e;
}
- if (importResult == null) {
+ if (loadResult == null) {
return null;
}
// From here on, either of the following must happen:
@@ -1244,8 +1236,8 @@
packageId,
buildFilePath,
file,
- importResult.loadedModules,
- importResult.fileDependencies,
+ loadResult.loadedModules,
+ loadResult.fileDependencies,
defaultVisibility,
starlarkSemantics,
globberWithSkyframeGlobDeps);
@@ -1310,12 +1302,12 @@
}
}
- /** A simple value class to store the result of the Starlark imports. */
- static final class StarlarkImportResult {
+ /** A simple value class to store the result of the Starlark loads. */
+ static final class BzlLoadResult {
final Map<String, Module> loadedModules;
final ImmutableList<Label> fileDependencies;
- private StarlarkImportResult(
+ private BzlLoadResult(
Map<String, Module> loadedModules, ImmutableList<Label> fileDependencies) {
this.loadedModules = loadedModules;
this.fileDependencies = fileDependencies;
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
index 7218385..8804524 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
@@ -47,8 +47,7 @@
SkyFunctionName.createHermetic("AST_FILE_LOOKUP");
public static final SkyFunctionName STARLARK_BUILTINS =
SkyFunctionName.createHermetic("STARLARK_BUILTINS");
- public static final SkyFunctionName STARLARK_IMPORTS_LOOKUP =
- SkyFunctionName.createHermetic("STARLARK_IMPORTS_LOOKUP");
+ public static final SkyFunctionName BZL_LOAD = SkyFunctionName.createHermetic("BZL_LOAD");
public static final SkyFunctionName GLOB = SkyFunctionName.createHermetic("GLOB");
public static final SkyFunctionName PACKAGE = SkyFunctionName.createHermetic("PACKAGE");
static final SkyFunctionName PACKAGE_ERROR = SkyFunctionName.createHermetic("PACKAGE_ERROR");
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
index a11b714..c16dffe 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
@@ -262,7 +262,7 @@
// Cache of partially constructed Package instances, stored between reruns of the PackageFunction
// (because of missing dependencies, within the same evaluate() run) to avoid loading the same
- // package twice (first time loading to find imported bzl files and declare Skyframe
+ // package twice (first time loading to find load()ed bzl files and declare Skyframe
// dependencies).
private final Cache<PackageIdentifier, LoadedPackageCacheEntry> packageFunctionCache =
newPkgFunctionCache();
@@ -270,9 +270,8 @@
private final Cache<PackageIdentifier, StarlarkFile> buildFileSyntaxCache =
newBuildFileSyntaxCache();
- // Cache of parsed bzl files, for use when we're inlining ASTFileLookupValue in
- // StarlarkImportLookupValue. See the comments in StarlarkLookupFunction for motivations and
- // details.
+ // Cache of parsed bzl files, for use when we're inlining ASTFileLookupFunction in
+ // BzlLoadFunction. See the comments in BzlLoadFunction for motivations and details.
private final Cache<Label, ASTFileLookupValue> astFileLookupValueCache =
CacheBuilder.newBuilder().build();
@@ -471,8 +470,8 @@
private ImmutableMap<SkyFunctionName, SkyFunction> skyFunctions(PackageFactory pkgFactory) {
ConfiguredRuleClassProvider ruleClassProvider =
(ConfiguredRuleClassProvider) pkgFactory.getRuleClassProvider();
- StarlarkImportLookupFunction starlarkImportLookupFunctionForInliningPackageAndWorkspaceNodes =
- getStarlarkImportLookupFunctionForInliningPackageAndWorkspaceNodes();
+ BzlLoadFunction bzlLoadFunctionForInliningPackageAndWorkspaceNodes =
+ getBzlLoadFunctionForInliningPackageAndWorkspaceNodes();
// TODO(janakr): use this semaphore to bound memory usage for SkyFunctions besides
// ConfiguredTargetFunction that may have a large temporary memory blow-up.
Semaphore cpuBoundSemaphore = new Semaphore(ResourceUsage.getAvailableProcessors());
@@ -503,9 +502,7 @@
SkyFunctions.AST_FILE_LOOKUP,
new ASTFileLookupFunction(ruleClassProvider, DigestHashFunction.getDefaultUnchecked()));
map.put(SkyFunctions.STARLARK_BUILTINS, new StarlarkBuiltinsFunction());
- map.put(
- SkyFunctions.STARLARK_IMPORTS_LOOKUP,
- newStarlarkImportLookupFunction(ruleClassProvider, pkgFactory));
+ map.put(SkyFunctions.BZL_LOAD, newBzlLoadFunction(ruleClassProvider, pkgFactory));
map.put(SkyFunctions.GLOB, newGlobFunction());
map.put(SkyFunctions.TARGET_PATTERN, new TargetPatternFunction());
map.put(SkyFunctions.PREPARE_DEPS_OF_PATTERNS, new PrepareDepsOfPatternsFunction());
@@ -541,7 +538,7 @@
packageFunctionCache,
buildFileSyntaxCache,
numPackagesLoaded,
- starlarkImportLookupFunctionForInliningPackageAndWorkspaceNodes,
+ bzlLoadFunctionForInliningPackageAndWorkspaceNodes,
packageProgress,
actionOnIOExceptionReadingBuildFile,
tracksStateForIncrementality()
@@ -586,7 +583,7 @@
ruleClassProvider,
pkgFactory,
directories,
- starlarkImportLookupFunctionForInliningPackageAndWorkspaceNodes));
+ bzlLoadFunctionForInliningPackageAndWorkspaceNodes));
map.put(SkyFunctions.EXTERNAL_PACKAGE, new ExternalPackageFunction(externalPackageHelper));
map.put(
SkyFunctions.TARGET_COMPLETION,
@@ -657,14 +654,13 @@
}
@Nullable
- protected StarlarkImportLookupFunction
- getStarlarkImportLookupFunctionForInliningPackageAndWorkspaceNodes() {
+ protected BzlLoadFunction getBzlLoadFunctionForInliningPackageAndWorkspaceNodes() {
return null;
}
- protected SkyFunction newStarlarkImportLookupFunction(
+ protected SkyFunction newBzlLoadFunction(
RuleClassProvider ruleClassProvider, PackageFactory pkgFactory) {
- return StarlarkImportLookupFunction.create(
+ return BzlLoadFunction.create(
ruleClassProvider,
this.pkgFactory,
DigestHashFunction.getDefaultUnchecked(),
@@ -981,7 +977,7 @@
private static final ImmutableSet<SkyFunctionName> LOADING_TYPES =
ImmutableSet.of(
SkyFunctions.PACKAGE,
- SkyFunctions.STARLARK_IMPORTS_LOOKUP,
+ SkyFunctions.BZL_LOAD,
SkyFunctions.AST_FILE_LOOKUP,
SkyFunctions.GLOB);
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsFunction.java
index 56bca62..4972250 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsFunction.java
@@ -27,7 +27,7 @@
import javax.annotation.Nullable;
// TODO(brandjon): Determine places where we need to teach Skyframe about this Skyfunction. Look for
-// special treatment of StarlarkImportLookupFunction or ASTFileLookupFunction in existing code.
+// special treatment of BzlLoadFunction or ASTFileLookupFunction in existing code.
// TODO(brandjon): Add support to StarlarkModuleCycleReporter to pretty-print cycles involving
// @builtins. Blocked on us actually loading files from @builtins.
@@ -37,8 +37,7 @@
* exported by {@code @builtins//:exports.bzl}.
*
* <p>This function has a trivial key, so there can only be one value in the build at a time. It has
- * a single dependency, on the result of evaluating the exports.bzl file to a {@link
- * StarlarkImportLookupValue}.
+ * a single dependency, on the result of evaluating the exports.bzl file to a {@link BzlLoadValue}.
*
* <p>See also the design doc:
* https://docs.google.com/document/d/1GW7UVo1s9X0cti9OMgT3ga5ozKYUWLPk9k8c4-34rC4/edit
@@ -64,12 +63,12 @@
throws StarlarkBuiltinsFunctionException, InterruptedException {
// skyKey is a singleton, unused.
- // TODO(brandjon): Replace by @builtins//:exports once StarlarkImportLookupFunction can resolve
- // the @builtins namespace.
+ // TODO(brandjon): Replace by @builtins//:exports once BzlLoadFunction can resolve the @builtins
+ // namespace.
SkyKey exportsKey =
- StarlarkImportLookupValue.packageBzlKey(
+ BzlLoadValue.packageBzlKey(
Label.parseAbsoluteUnchecked("//tools/builtins_staging:exports.bzl"));
- StarlarkImportLookupValue exportsValue = (StarlarkImportLookupValue) env.getValue(exportsKey);
+ BzlLoadValue exportsValue = (BzlLoadValue) env.getValue(exportsKey);
if (exportsValue == null) {
return null;
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsValue.java
index e53db49..2cf1e44 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsValue.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkBuiltinsValue.java
@@ -24,7 +24,7 @@
* pseudo-repository.
*
* <p>These are parsed from {@code @builtins//:exports.bzl}, but not validated until they're used by
- * {@link PackageFunction} and {@link StarlarkImportLookupFunction}.
+ * {@link PackageFunction} and {@link BzlLoadFunction}.
*/
public final class StarlarkBuiltinsValue implements SkyValue {
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkModuleCycleReporter.java b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkModuleCycleReporter.java
index 83c773d..1a53ebb 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkModuleCycleReporter.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/StarlarkModuleCycleReporter.java
@@ -33,7 +33,7 @@
public class StarlarkModuleCycleReporter implements CyclesReporter.SingleCycleReporter {
private static final Predicate<SkyKey> IS_STARLARK_MODULE_SKY_KEY =
- SkyFunctions.isSkyFunction(SkyFunctions.STARLARK_IMPORTS_LOOKUP);
+ SkyFunctions.isSkyFunction(SkyFunctions.BZL_LOAD);
private static final Predicate<SkyKey> IS_PACKAGE_SKY_KEY =
SkyFunctions.isSkyFunction(SkyFunctions.PACKAGE);
@@ -50,8 +50,8 @@
private static final Predicate<SkyKey> IS_REPOSITORY_DIRECTORY =
SkyFunctions.isSkyFunction(SkyFunctions.REPOSITORY_DIRECTORY);
- private static final Predicate<SkyKey> IS_STARLARK_IMPORTS_LOOKUP =
- SkyFunctions.isSkyFunction(SkyFunctions.STARLARK_IMPORTS_LOOKUP);
+ private static final Predicate<SkyKey> IS_BZL_LOAD =
+ SkyFunctions.isSkyFunction(SkyFunctions.BZL_LOAD);
private static final Predicate<SkyKey> IS_EXTERNAL_PACKAGE =
SkyFunctions.isSkyFunction(SkyFunctions.EXTERNAL_PACKAGE);
@@ -95,8 +95,8 @@
new Function<SkyKey, String>() {
@Override
public String apply(SkyKey input) {
- if (input.argument() instanceof StarlarkImportLookupValue.Key) {
- return ((StarlarkImportLookupValue.Key) input.argument()).getLabel().toString();
+ if (input.argument() instanceof BzlLoadValue.Key) {
+ return ((BzlLoadValue.Key) input.argument()).getLabel().toString();
} else if (input.argument() instanceof PackageIdentifier) {
return ((PackageIdentifier) input.argument()) + "/BUILD";
} else if (input.argument() instanceof WorkspaceFileValue.WorkspaceFileKey) {
@@ -158,11 +158,9 @@
StringBuilder message = new StringBuilder();
- if (Iterables.any(cycle, IS_STARLARK_IMPORTS_LOOKUP)) {
+ if (Iterables.any(cycle, IS_BZL_LOAD)) {
Label fileLabel =
- ((StarlarkImportLookupValue.Key)
- Iterables.getLast(Iterables.filter(cycle, IS_STARLARK_IMPORTS_LOOKUP)))
- .getLabel();
+ ((BzlLoadValue.Key) Iterables.getLast(Iterables.filter(cycle, IS_BZL_LOAD))).getLabel();
message.append("Failed to load Starlark extension '").append(fileLabel).append("'.\n");
}
@@ -193,11 +191,9 @@
// repositories were defined.
requestRepoDefinitions(eventHandler, repos);
return true;
- } else if (Iterables.any(cycle, IS_STARLARK_IMPORTS_LOOKUP)) {
+ } else if (Iterables.any(cycle, IS_BZL_LOAD)) {
Label fileLabel =
- ((StarlarkImportLookupValue.Key)
- Iterables.getLast(Iterables.filter(cycle, IS_STARLARK_IMPORTS_LOOKUP)))
- .getLabel();
+ ((BzlLoadValue.Key) Iterables.getLast(Iterables.filter(cycle, IS_BZL_LOAD))).getLabel();
eventHandler.handle(
Event.error(null, "Failed to load Starlark extension '" + fileLabel + "'.\n"));
return true;
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/WorkspaceFileFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/WorkspaceFileFunction.java
index 0edfd38..4188a18 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/WorkspaceFileFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/WorkspaceFileFunction.java
@@ -26,7 +26,7 @@
import com.google.devtools.build.lib.packages.WorkspaceFactory;
import com.google.devtools.build.lib.packages.WorkspaceFileValue;
import com.google.devtools.build.lib.packages.WorkspaceFileValue.WorkspaceFileKey;
-import com.google.devtools.build.lib.skyframe.PackageFunction.StarlarkImportResult;
+import com.google.devtools.build.lib.skyframe.PackageFunction.BzlLoadResult;
import com.google.devtools.build.lib.syntax.Module;
import com.google.devtools.build.lib.syntax.Mutability;
import com.google.devtools.build.lib.syntax.StarlarkFile;
@@ -45,18 +45,18 @@
private final PackageFactory packageFactory;
private final BlazeDirectories directories;
private final RuleClassProvider ruleClassProvider;
- private final StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining;
+ private final BzlLoadFunction bzlLoadFunctionForInlining;
private static final PackageIdentifier rootPackage = PackageIdentifier.createInMainRepo("");
public WorkspaceFileFunction(
RuleClassProvider ruleClassProvider,
PackageFactory packageFactory,
BlazeDirectories directories,
- StarlarkImportLookupFunction starlarkImportLookupFunctionForInlining) {
+ BzlLoadFunction bzlLoadFunctionForInlining) {
this.packageFactory = packageFactory;
this.directories = directories;
this.ruleClassProvider = ruleClassProvider;
- this.starlarkImportLookupFunctionForInlining = starlarkImportLookupFunctionForInlining;
+ this.bzlLoadFunctionForInlining = bzlLoadFunctionForInlining;
}
@Override
@@ -84,7 +84,7 @@
return new WorkspaceFileValue(
/* pkg = */ builder.build(),
/* loadedModules = */ ImmutableMap.<String, Module>of(),
- /* importToChunkMap = */ ImmutableMap.<String, Integer>of(),
+ /* loadToChunkMap = */ ImmutableMap.<String, Integer>of(),
/* bindings = */ ImmutableMap.<String, Object>of(),
workspaceFile,
/* idx = */ 0, // first fragment
@@ -123,19 +123,19 @@
prevValue.getPackage(), prevValue.getLoadedModules(), prevValue.getBindings());
}
StarlarkFile ast = workspaceASTValue.getASTs().get(key.getIndex());
- StarlarkImportResult importResult =
- PackageFunction.fetchImportsFromBuildFile(
+ BzlLoadResult loadResult =
+ PackageFunction.fetchLoadsFromBuildFile(
workspaceFile,
rootPackage,
/*repoMapping=*/ ImmutableMap.of(),
ast,
key.getIndex(),
env,
- starlarkImportLookupFunctionForInlining);
- if (importResult == null) {
+ bzlLoadFunctionForInlining);
+ if (loadResult == null) {
return null;
}
- parser.execute(ast, importResult.loadedModules, key);
+ parser.execute(ast, loadResult.loadedModules, key);
} catch (NoSuchPackageException e) {
throw new WorkspaceFileFunctionException(e, Transience.PERSISTENT);
} catch (NameConflictException e) {
@@ -146,7 +146,7 @@
return new WorkspaceFileValue(
builder.build(),
parser.getLoadedModules(),
- createImportToChunkMap(prevValue, parser, key),
+ createLoadToChunkMap(prevValue, parser, key),
parser.getVariableBindings(),
workspaceFile,
key.getIndex(),
@@ -159,10 +159,11 @@
}
/**
- * This returns a map from import statement to the chunk the
- * import statement originated from.
+ * This returns a map from load statement to the chunk the load statement originated from.
*
- * For example, if the WORKSPACE file looked like the following:
+ * <p>For example, if the WORKSPACE file looked like the following:
+ *
+ * <pre>
* load(":a.bzl", "a")
* x = 0
* load(":b.bzl", "b")
@@ -170,12 +171,13 @@
* load(":a.bzl", "a1")
* load(":c.bzl", "c")
* x = 2
+ * </pre>
*
- * Then the map for chunk 0 would be: {@code {":a.bzl" : 0}}
- * for chunk 1 would be: {@code {":a.bzl" : 0, ":b.bzl" : 1}}
- * for chunk 2 would be: {@code {":a.bzl" : 0, ":b.bzl" : 1, ":c.bzl" : 2}}
+ * Then the map for chunk 0 would be {@code {":a.bzl" : 0}}, for chunk 1 it'd be: {@code {":a.bzl"
+ * : 0, ":b.bzl" : 1}}, and for chunk 2 it'd be: {@code {":a.bzl" : 0, ":b.bzl" : 1, ":c.bzl" :
+ * 2}}
*/
- private ImmutableMap<String, Integer> createImportToChunkMap(
+ private static ImmutableMap<String, Integer> createLoadToChunkMap(
WorkspaceFileValue prevValue, WorkspaceFactory parser, WorkspaceFileKey key) {
ImmutableMap.Builder<String, Integer> builder = new ImmutableMap.Builder<String, Integer>();
if (prevValue == null) {
@@ -183,9 +185,9 @@
builder.put(loadString, key.getIndex());
}
} else {
- builder.putAll(prevValue.getImportToChunkMap());
+ builder.putAll(prevValue.getLoadToChunkMap());
for (String label : parser.getLoadedModules().keySet()) {
- if (!prevValue.getImportToChunkMap().containsKey(label)) {
+ if (!prevValue.getLoadToChunkMap().containsKey(label)) {
builder.put(label, key.getIndex());
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/packages/AbstractPackageLoader.java b/src/main/java/com/google/devtools/build/lib/skyframe/packages/AbstractPackageLoader.java
index d8fd5d6..25e2735 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/packages/AbstractPackageLoader.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/packages/AbstractPackageLoader.java
@@ -45,6 +45,7 @@
import com.google.devtools.build.lib.repository.ExternalPackageHelper;
import com.google.devtools.build.lib.skyframe.ASTFileLookupFunction;
import com.google.devtools.build.lib.skyframe.BlacklistedPackagePrefixesFunction;
+import com.google.devtools.build.lib.skyframe.BzlLoadFunction;
import com.google.devtools.build.lib.skyframe.ContainingPackageLookupFunction;
import com.google.devtools.build.lib.skyframe.ExternalFilesHelper;
import com.google.devtools.build.lib.skyframe.ExternalFilesHelper.ExternalFileAction;
@@ -66,7 +67,6 @@
import com.google.devtools.build.lib.skyframe.PrecomputedValue;
import com.google.devtools.build.lib.skyframe.RepositoryMappingFunction;
import com.google.devtools.build.lib.skyframe.SkyFunctions;
-import com.google.devtools.build.lib.skyframe.StarlarkImportLookupFunction;
import com.google.devtools.build.lib.skyframe.WorkspaceASTFunction;
import com.google.devtools.build.lib.skyframe.WorkspaceFileFunction;
import com.google.devtools.build.lib.skyframe.WorkspaceNameFunction;
@@ -444,8 +444,8 @@
SkyFunctions.AST_FILE_LOOKUP,
new ASTFileLookupFunction(ruleClassProvider, digestHashFunction))
.put(
- SkyFunctions.STARLARK_IMPORTS_LOOKUP,
- StarlarkImportLookupFunction.create(
+ SkyFunctions.BZL_LOAD,
+ BzlLoadFunction.create(
ruleClassProvider,
pkgFactory,
digestHashFunction,
@@ -455,10 +455,7 @@
.put(
WorkspaceFileValue.WORKSPACE_FILE,
new WorkspaceFileFunction(
- ruleClassProvider,
- pkgFactory,
- directories,
- /*starlarkImportLookupFunctionForInlining=*/ null))
+ ruleClassProvider, pkgFactory, directories, /*bzlLoadFunctionForInlining=*/ null))
.put(SkyFunctions.EXTERNAL_PACKAGE, new ExternalPackageFunction(getExternalPackageHelper()))
.put(SkyFunctions.REPOSITORY_MAPPING, new RepositoryMappingFunction())
.put(
@@ -470,7 +467,7 @@
packageFunctionCache,
astCache,
/*numPackagesLoaded=*/ new AtomicInteger(0),
- /*starlarkImportLookupFunctionForInlining=*/ null,
+ /*bzlLoadFunctionForInlining=*/ null,
/*packageProgress=*/ null,
getActionOnIOExceptionReadingBuildFile(),
// Tell PackageFunction to optimize for our use-case of no incrementality.
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Eval.java b/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
index 0c3c3bf..edaf815 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
@@ -55,7 +55,7 @@
return flow;
}
- // Hack for StarlarkImportLookupFunction's "export" semantics.
+ // Hack for BzlLoadFunction's "export" semantics.
// We enable it only for statements outside any function (isToplevelFunction)
// and outside any if- or for- statements (!indented).
if (isToplevelFunction && !indented && fr.thread.postAssignHook != null) {
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/StarlarkThread.java b/src/main/java/com/google/devtools/build/lib/syntax/StarlarkThread.java
index 5320e0f..c7c5d0e 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/StarlarkThread.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/StarlarkThread.java
@@ -350,9 +350,8 @@
* Specifies a hook function to be run after each assignment at top level.
*
* <p>This is a short-term hack to allow us to consolidate all StarlarkFile execution in one place
- * even while StarlarkImportLookupFunction implements the old "export" behavior, in which rules,
- * aspects and providers are "exported" as soon as they are assigned, not at the end of file
- * execution.
+ * even while BzlLoadFunction implements the old "export" behavior, in which rules, aspects and
+ * providers are "exported" as soon as they are assigned, not at the end of file execution.
*/
public void setPostAssignHook(PostAssignHook postAssignHook) {
this.postAssignHook = postAssignHook;
