Automated rollback of commit 7ba939dfd5df48903929e9c14ebd0449656403e4.

*** Reason for rollback ***

Likely cause for non-determinism in skyframe

*** Original change description ***

Cache SkylarkLookupImportValues in memory so that we don't recompute them multiple times.

PiperOrigin-RevId: 188729929

4 files changed, 43 insertions, 461 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/CachedSkylarkImportLookupValueAndDeps.java b/src/main/java/com/google/devtools/build/lib/skyframe/CachedSkylarkImportLookupValueAndDeps.java
deleted file mode 100644
index 4cee4ba3df..0000000000
--- a/src/main/java/com/google/devtools/build/lib/skyframe/CachedSkylarkImportLookupValueAndDeps.java
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2018 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.skyframe;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.devtools.build.skyframe.SkyKey;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-class CachedSkylarkImportLookupValueAndDeps {
-  private final SkylarkImportLookupValue value;
-  // We store the deps separately so that we can let go of the value when the cache drops it.
-  final CachedSkylarkImportLookupFunctionDeps deps;
-
-  private CachedSkylarkImportLookupValueAndDeps(
-      SkylarkImportLookupValue value, CachedSkylarkImportLookupFunctionDeps deps) {
-    this.value = value;
-    this.deps = deps;
-  }
-
-  SkylarkImportLookupValue getValue() {
-    return value;
-  }
-
-  static CachedSkylarkImportLookupValueAndDeps.Builder newBuilder() {
-    return new CachedSkylarkImportLookupValueAndDeps.Builder();
-  }
-
-  static class Builder {
-    private final CachedSkylarkImportLookupFunctionDeps.Builder depsBuilder =
-        CachedSkylarkImportLookupFunctionDeps.newBuilder();
-    private SkylarkImportLookupValue value;
-
-    @CanIgnoreReturnValue
-    Builder addDep(SkyKey key) {
-      depsBuilder.addDep(key);
-      return this;
-    }
-
-    @CanIgnoreReturnValue
-    Builder addDeps(Iterable<SkyKey> keys) {
-      depsBuilder.addDeps(keys);
-      return this;
-    }
-
-    @CanIgnoreReturnValue
-    Builder addTransitiveDeps(CachedSkylarkImportLookupValueAndDeps transitiveDeps) {
-      depsBuilder.addTransitiveDeps(transitiveDeps.deps);
-      return this;
-    }
-
-    @CanIgnoreReturnValue
-    Builder setValue(SkylarkImportLookupValue value) {
-      this.value = value;
-      return this;
-    }
-
-    CachedSkylarkImportLookupValueAndDeps build() {
-      return new CachedSkylarkImportLookupValueAndDeps(value, depsBuilder.build());
-    }
-  }
-
-  static class CachedSkylarkImportLookupFunctionDeps implements Iterable<Iterable<SkyKey>> {
-    private final ImmutableList<Iterable<SkyKey>> deps;
-
-    private CachedSkylarkImportLookupFunctionDeps(ImmutableList<Iterable<SkyKey>> deps) {
-      this.deps = deps;
-    }
-
-    static CachedSkylarkImportLookupFunctionDeps.Builder newBuilder() {
-      return new CachedSkylarkImportLookupFunctionDeps.Builder();
-    }
-
-    @Override
-    public Iterator<Iterable<SkyKey>> iterator() {
-      return deps.iterator();
-    }
-
-    static class Builder {
-      private final List<Iterable<SkyKey>> deps = new ArrayList<>();
-
-      // We only add the ASTFileLookupFunction through this so we don't need to worry about memory
-      // optimizations by adding it raw.
-      @CanIgnoreReturnValue
-      Builder addDep(SkyKey key) {
-        deps.add(ImmutableList.of(key));
-        return this;
-      }
-
-      @CanIgnoreReturnValue
-      Builder addDeps(Iterable<SkyKey> keys) {
-        deps.add(keys);
-        return this;
-      }
-
-      @CanIgnoreReturnValue
-      Builder addTransitiveDeps(CachedSkylarkImportLookupFunctionDeps transitiveDeps) {
-        Iterables.addAll(deps, transitiveDeps);
-        return this;
-      }
-
-      CachedSkylarkImportLookupFunctionDeps build() {
-        return new CachedSkylarkImportLookupFunctionDeps(ImmutableList.copyOf(deps));
-      }
-    }
-  }
-}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkylarkImportLookupFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkylarkImportLookupFunction.java
index cddbf485bf..ad4c5a9d74 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkylarkImportLookupFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkylarkImportLookupFunction.java
@@ -15,8 +15,6 @@ package com.google.devtools.build.lib.skyframe;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Predicates;
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -29,7 +27,6 @@ import com.google.common.collect.Multimap;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.cmdline.LabelSyntaxException;
 import com.google.devtools.build.lib.cmdline.PackageIdentifier;
-import com.google.devtools.build.lib.concurrent.BlazeInterners;
 import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.events.EventHandler;
 import com.google.devtools.build.lib.events.ExtendedEventHandler.Postable;
@@ -50,7 +47,6 @@ import com.google.devtools.build.lib.syntax.SkylarkImport;
 import com.google.devtools.build.lib.syntax.SkylarkSemantics;
 import com.google.devtools.build.lib.syntax.Statement;
 import com.google.devtools.build.lib.vfs.PathFragment;
-import com.google.devtools.build.skyframe.RecordingSkyFunctionEnvironment;
 import com.google.devtools.build.skyframe.SkyFunction;
 import com.google.devtools.build.skyframe.SkyFunctionException;
 import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
@@ -61,26 +57,22 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.logging.Logger;
 import javax.annotation.Nullable;
 
 /**
  * A Skyframe function to look up and import a single Skylark extension.
  *
- * <p>Given a {@link Label} referencing a Skylark 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 SkylarkImportLookupValue} that encapsulates the loaded {@link
- * Extension} and {@link SkylarkFileDependency} information. If loading is unsuccessful, throws a
- * {@link SkylarkImportLookupFunctionException} that encapsulates the cause of the failure.
+ * <p> Given a {@link Label} referencing a Skylark 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 SkylarkImportLookupValue} that encapsulates
+ * the loaded {@link Extension} and {@link SkylarkFileDependency} information. If loading is
+ * unsuccessful, throws a {@link SkylarkImportLookupFunctionException} that encapsulates the
+ * cause of the failure.
  */
 public class SkylarkImportLookupFunction implements SkyFunction {
 
   private final RuleClassProvider ruleClassProvider;
   private final PackageFactory packageFactory;
-  private Cache<SkyKey, CachedSkylarkImportLookupValueAndDeps> skylarkImportLookupValueCache;
-
-  private static final Logger logger =
-      Logger.getLogger(SkylarkImportLookupFunction.class.getName());
 
   public SkylarkImportLookupFunction(
     RuleClassProvider ruleClassProvider, PackageFactory packageFactory) {
@@ -89,17 +81,11 @@ public class SkylarkImportLookupFunction implements SkyFunction {
   }
 
   @Override
-  @Nullable
-  public SkyValue compute(SkyKey skyKey, Environment env)
-      throws SkyFunctionException, InterruptedException {
+  public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+      InterruptedException {
     SkylarkImportLookupKey key = (SkylarkImportLookupKey) skyKey.argument();
     try {
-      return computeInternal(
-          key.importLabel,
-          key.inWorkspace,
-          env,
-          /*alreadyVisited=*/ null,
-          /*inlineCachedValueBuilder=*/ null);
+      return computeInternal(key.importLabel, key.inWorkspace, env, null);
     } catch (InconsistentFilesystemException e) {
       throw new SkylarkImportLookupFunctionException(e, Transience.PERSISTENT);
     } catch (SkylarkImportFailedException e) {
@@ -107,88 +93,32 @@ public class SkylarkImportLookupFunction implements SkyFunction {
     }
   }
 
-  @Nullable
-  SkylarkImportLookupValue computeWithInlineCalls(
+  SkyValue computeWithInlineCalls(
       SkyKey skyKey, Environment env, LinkedHashMap<Label, SkylarkImportLookupValue> visited)
       throws InconsistentFilesystemException, SkylarkImportFailedException, InterruptedException {
-    CachedSkylarkImportLookupValueAndDeps cachedSkylarkImportLookupValueAndDeps =
-        computeWithInlineCallsInternal(skyKey, env, visited);
-    if (cachedSkylarkImportLookupValueAndDeps == null) {
-      return null;
-    }
-    for (Iterable<SkyKey> depGroup : cachedSkylarkImportLookupValueAndDeps.deps) {
-      env.getValues(depGroup);
-    }
-    return cachedSkylarkImportLookupValueAndDeps.getValue();
+    return computeWithInlineCallsInternal(skyKey, env, visited);
   }
 
-  @Nullable
-  private CachedSkylarkImportLookupValueAndDeps computeWithInlineCallsInternal(
+  private SkyValue computeWithInlineCallsInternal(
       SkyKey skyKey, Environment env, LinkedHashMap<Label, SkylarkImportLookupValue> visited)
       throws InconsistentFilesystemException, SkylarkImportFailedException, InterruptedException {
     SkylarkImportLookupKey key = (SkylarkImportLookupKey) skyKey.argument();
     SkylarkImportLookupValue precomputedResult = visited.get(key.importLabel);
     if (precomputedResult != null) {
-      // We have already registered all the deps for this value.
-      return CachedSkylarkImportLookupValueAndDeps.newBuilder().setValue(precomputedResult).build();
-    }
-    // Note that we can't block other threads on the computation of this value due to a potential
-    // deadlock on a cycle. Although we are repeating some work, it is possible we have an import
-    // cycle where one thread starts at one side of the cycle and the other thread starts at the
-    // other side, and they then wait forever on the results of each others computations.
-    CachedSkylarkImportLookupValueAndDeps cachedSkylarkImportLookupValueAndDeps =
-        skylarkImportLookupValueCache.getIfPresent(skyKey);
-    if (cachedSkylarkImportLookupValueAndDeps != null) {
-      return cachedSkylarkImportLookupValueAndDeps;
-    }
-
-    CachedSkylarkImportLookupValueAndDeps.Builder inlineCachedValueBuilder =
-        CachedSkylarkImportLookupValueAndDeps.newBuilder();
-    Preconditions.checkState(
-        !(env instanceof RecordingSkyFunctionEnvironment),
-        "Found nested RecordingSkyFunctionEnvironment but it should have been stripped: %s",
-        env);
-    RecordingSkyFunctionEnvironment recordingEnv =
-        new RecordingSkyFunctionEnvironment(
-            env,
-            addedKey -> inlineCachedValueBuilder.addDep(addedKey),
-            addedSkyKeys -> inlineCachedValueBuilder.addDeps(addedSkyKeys));
-    SkylarkImportLookupValue value =
-        computeInternal(
-            key.importLabel,
-            key.inWorkspace,
-            recordingEnv,
-            Preconditions.checkNotNull(visited, key.importLabel),
-            inlineCachedValueBuilder);
-    if (value != null) {
-      inlineCachedValueBuilder.setValue(value);
-      cachedSkylarkImportLookupValueAndDeps = inlineCachedValueBuilder.build();
-      skylarkImportLookupValueCache.put(skyKey, cachedSkylarkImportLookupValueAndDeps);
-    }
-    return cachedSkylarkImportLookupValueAndDeps;
-  }
-
-  public void resetCache() {
-    if (skylarkImportLookupValueCache != null) {
-      logger.info(
-          "Skylark inlining cache stats from earlier build: "
-              + skylarkImportLookupValueCache.stats());
-    }
-    skylarkImportLookupValueCache =
-        CacheBuilder.newBuilder()
-            .concurrencyLevel(BlazeInterners.concurrencyLevel())
-            .maximumSize(10000)
-            .recordStats()
-            .build();
+      return precomputedResult;
+    }
+    return computeInternal(
+        key.importLabel,
+        key.inWorkspace,
+        env,
+        Preconditions.checkNotNull(visited, key.importLabel));
   }
 
-  @Nullable
-  private SkylarkImportLookupValue computeInternal(
+  private SkyValue computeInternal(
       Label fileLabel,
       boolean inWorkspace,
       Environment env,
-      @Nullable LinkedHashMap<Label, SkylarkImportLookupValue> alreadyVisited,
-      @Nullable CachedSkylarkImportLookupValueAndDeps.Builder inlineCachedValueBuilder)
+      @Nullable LinkedHashMap<Label, SkylarkImportLookupValue> alreadyVisited)
       throws InconsistentFilesystemException, SkylarkImportFailedException, InterruptedException {
     PathFragment filePath = fileLabel.toPathFragment();
 
@@ -220,6 +150,8 @@ public class SkylarkImportLookupFunction implements SkyFunction {
 
     // Process the load statements in the file.
     ImmutableList<SkylarkImport> imports = ast.getImports();
+    Map<String, Extension> extensionsForImports = Maps.newHashMapWithExpectedSize(imports.size());
+    ImmutableList.Builder<SkylarkFileDependency> fileDependencies = ImmutableList.builder();
     ImmutableMap<String, Label> labelsForImports;
 
     // Find the labels corresponding to the load statements.
@@ -242,9 +174,6 @@ public class SkylarkImportLookupFunction implements SkyFunction {
       skylarkImportMap = env.getValues(importLookupKeys);
       valuesMissing = env.valuesMissing();
     } else {
-      Preconditions.checkNotNull(
-          inlineCachedValueBuilder,
-          "Expected inline cached value builder to be not-null when inlining.");
       // Inlining calls to SkylarkImportLookupFunction.
       if (alreadyVisited.containsKey(fileLabel)) {
         ImmutableList<Label> cycle =
@@ -254,16 +183,10 @@ public class SkylarkImportLookupFunction implements SkyFunction {
       }
       alreadyVisited.put(fileLabel, null);
       skylarkImportMap = Maps.newHashMapWithExpectedSize(imports.size());
-
-      Preconditions.checkState(
-          env instanceof RecordingSkyFunctionEnvironment,
-          "Expected to be recording dep requests when inlining SkylarkImportLookupFunction: %s",
-          fileLabel);
-      Environment strippedEnv = ((RecordingSkyFunctionEnvironment) env).getDelegate();
       for (SkyKey importLookupKey : importLookupKeys) {
-        CachedSkylarkImportLookupValueAndDeps cachedValue =
-            this.computeWithInlineCallsInternal(importLookupKey, strippedEnv, alreadyVisited);
-        if (cachedValue == null) {
+        SkyValue skyValue =
+            this.computeWithInlineCallsInternal(importLookupKey, env, alreadyVisited);
+        if (skyValue == null) {
           Preconditions.checkState(
               env.valuesMissing(), "no skylark import value for %s", importLookupKey);
           // We continue making inline calls even if some requested values are missing, to maximize
@@ -271,9 +194,7 @@ public class SkylarkImportLookupFunction implements SkyFunction {
           // quadratic number of restarts.
           valuesMissing = true;
         } else {
-          SkyValue skyValue = cachedValue.getValue();
           skylarkImportMap.put(importLookupKey, skyValue);
-          inlineCachedValueBuilder.addTransitiveDeps(cachedValue);
         }
       }
       // All imports traversed, this key can no longer be part of a cycle.
@@ -285,9 +206,6 @@ public class SkylarkImportLookupFunction implements SkyFunction {
     }
 
     // Process the loaded imports.
-    Map<String, Extension> extensionsForImports = Maps.newHashMapWithExpectedSize(imports.size());
-    ImmutableList.Builder<SkylarkFileDependency> fileDependencies =
-        ImmutableList.builderWithExpectedSize(labelsForImports.size());
     for (Entry<String, Label> importEntry : labelsForImports.entrySet()) {
       String importString = importEntry.getKey();
       Label importLabel = importEntry.getValue();
@@ -298,10 +216,15 @@ public class SkylarkImportLookupFunction implements SkyFunction {
       fileDependencies.add(importLookupValue.getDependency());
     }
 
-    // #createExtension does not request values from the Environment. It may post events to the
-    // Environment, but events do not matter when caching SkylarkImportLookupValues.
-    Extension extension =
-        createExtension(ast, fileLabel, extensionsForImports, skylarkSemantics, env, inWorkspace);
+    // Skylark UserDefinedFunction-s in that file will share this function definition Environment,
+    // which will be frozen by the time it is returned by createExtension.
+    Extension extension = createExtension(
+        ast,
+        fileLabel,
+        extensionsForImports,
+        skylarkSemantics,
+        env,
+        inWorkspace);
     SkylarkImportLookupValue result =
         new SkylarkImportLookupValue(
             extension, new SkylarkFileDependency(fileLabel, fileDependencies.build()));
@@ -320,13 +243,12 @@ public class SkylarkImportLookupFunction implements SkyFunction {
    * @throws SkylarkImportFailedException
    */
   @Nullable
-  private static ImmutableMap<PathFragment, Label> labelsForAbsoluteImports(
+  static ImmutableMap<PathFragment, Label> labelsForAbsoluteImports(
       ImmutableSet<PathFragment> pathsToLookup, Environment env)
       throws SkylarkImportFailedException, InterruptedException {
 
     // Import PathFragments are absolute, so there is a 1-1 mapping from corresponding Labels.
-    ImmutableMap.Builder<PathFragment, Label> outputMap =
-        ImmutableMap.builderWithExpectedSize(pathsToLookup.size());
+    ImmutableMap.Builder<PathFragment, Label> outputMap = new ImmutableMap.Builder<>();
 
     // The SkyKey here represents the directory containing an import PathFragment, hence there
     // can in general be multiple imports per lookup.
@@ -387,7 +309,7 @@ public class SkylarkImportLookupFunction implements SkyFunction {
       throw new SkylarkImportFailedException(e);
     }
 
-    return outputMap.build();
+  return outputMap.build();
   }
 
   /**
@@ -586,5 +508,10 @@ public class SkylarkImportLookupFunction implements SkyFunction {
         Transience transience) {
       super(e, transience);
     }
+
+    private SkylarkImportLookupFunctionException(BuildFileNotFoundException e,
+        Transience transience) {
+      super(e, transience);
+    }
   }
 }
diff --git a/src/main/java/com/google/devtools/build/skyframe/RecordingSkyFunctionEnvironment.java b/src/main/java/com/google/devtools/build/skyframe/RecordingSkyFunctionEnvironment.java
deleted file mode 100644
index 16b6c3fa23..0000000000
--- a/src/main/java/com/google/devtools/build/skyframe/RecordingSkyFunctionEnvironment.java
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2018 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.skyframe;
-
-import com.google.devtools.build.lib.events.ExtendedEventHandler;
-import com.google.devtools.build.lib.util.GroupedList;
-import com.google.devtools.build.skyframe.SkyFunction.Environment;
-import java.util.Map;
-import java.util.function.Consumer;
-import javax.annotation.Nullable;
-
-/** An environment that can observe the deps requested through getValue(s) calls. */
-public class RecordingSkyFunctionEnvironment implements Environment {
-
-  private final Environment delegate;
-  private final Consumer<SkyKey> skyKeyReceiver;
-  private final Consumer<Iterable<SkyKey>> skyKeysReceiver;
-
-  public RecordingSkyFunctionEnvironment(
-      Environment delegate,
-      Consumer<SkyKey> skyKeyReceiver,
-      Consumer<Iterable<SkyKey>> skyKeysReceiver) {
-    this.delegate = delegate;
-    this.skyKeyReceiver = skyKeyReceiver;
-    this.skyKeysReceiver = skyKeysReceiver;
-  }
-
-  private void recordDep(SkyKey key) {
-    skyKeyReceiver.accept(key);
-  }
-
-  @SuppressWarnings("unchecked") // Cast Iterable<? extends SkyKey> to Iterable<SkyKey>.
-  private void recordDeps(Iterable<? extends SkyKey> keys) {
-    skyKeysReceiver.accept((Iterable<SkyKey>) keys);
-  }
-
-  public Environment getDelegate() {
-    return delegate;
-  }
-
-  @Nullable
-  @Override
-  public SkyValue getValue(SkyKey valueName) throws InterruptedException {
-    recordDep(valueName);
-    return delegate.getValue(valueName);
-  }
-
-  @Nullable
-  @Override
-  public <E extends Exception> SkyValue getValueOrThrow(SkyKey depKey, Class<E> exceptionClass)
-      throws E, InterruptedException {
-    recordDep(depKey);
-    return delegate.getValueOrThrow(depKey, exceptionClass);
-  }
-
-  @Nullable
-  @Override
-  public <E1 extends Exception, E2 extends Exception> SkyValue getValueOrThrow(
-      SkyKey depKey, Class<E1> exceptionClass1, Class<E2> exceptionClass2)
-      throws E1, E2, InterruptedException {
-    recordDep(depKey);
-    return delegate.getValueOrThrow(depKey, exceptionClass1, exceptionClass2);
-  }
-
-  @Nullable
-  @Override
-  public <E1 extends Exception, E2 extends Exception, E3 extends Exception>
-      SkyValue getValueOrThrow(
-          SkyKey depKey,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3)
-          throws E1, E2, E3, InterruptedException {
-    recordDep(depKey);
-    return delegate.getValueOrThrow(depKey, exceptionClass1, exceptionClass2, exceptionClass3);
-  }
-
-  @Nullable
-  @Override
-  public <E1 extends Exception, E2 extends Exception, E3 extends Exception, E4 extends Exception>
-      SkyValue getValueOrThrow(
-          SkyKey depKey,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3,
-          Class<E4> exceptionClass4)
-          throws E1, E2, E3, E4, InterruptedException {
-    recordDep(depKey);
-    return delegate.getValueOrThrow(
-        depKey, exceptionClass1, exceptionClass2, exceptionClass3, exceptionClass4);
-  }
-
-  @Nullable
-  @Override
-  public <
-          E1 extends Exception,
-          E2 extends Exception,
-          E3 extends Exception,
-          E4 extends Exception,
-          E5 extends Exception>
-      SkyValue getValueOrThrow(
-          SkyKey depKey,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3,
-          Class<E4> exceptionClass4,
-          Class<E5> exceptionClass5)
-          throws E1, E2, E3, E4, E5, InterruptedException {
-    recordDep(depKey);
-    return delegate.getValueOrThrow(
-        depKey,
-        exceptionClass1,
-        exceptionClass2,
-        exceptionClass3,
-        exceptionClass4,
-        exceptionClass5);
-  }
-
-  @Override
-  public Map<SkyKey, SkyValue> getValues(Iterable<SkyKey> depKeys) throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValues(depKeys);
-  }
-
-  @Override
-  public <E extends Exception> Map<SkyKey, ValueOrException<E>> getValuesOrThrow(
-      Iterable<? extends SkyKey> depKeys, Class<E> exceptionClass) throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValuesOrThrow(depKeys, exceptionClass);
-  }
-
-  @Override
-  public <E1 extends Exception, E2 extends Exception>
-      Map<SkyKey, ValueOrException2<E1, E2>> getValuesOrThrow(
-          Iterable<? extends SkyKey> depKeys, Class<E1> exceptionClass1, Class<E2> exceptionClass2)
-          throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValuesOrThrow(depKeys, exceptionClass1, exceptionClass2);
-  }
-
-  @Override
-  public <E1 extends Exception, E2 extends Exception, E3 extends Exception>
-      Map<SkyKey, ValueOrException3<E1, E2, E3>> getValuesOrThrow(
-          Iterable<? extends SkyKey> depKeys,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3)
-          throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValuesOrThrow(depKeys, exceptionClass1, exceptionClass2, exceptionClass3);
-  }
-
-  @Override
-  public <E1 extends Exception, E2 extends Exception, E3 extends Exception, E4 extends Exception>
-      Map<SkyKey, ValueOrException4<E1, E2, E3, E4>> getValuesOrThrow(
-          Iterable<? extends SkyKey> depKeys,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3,
-          Class<E4> exceptionClass4)
-          throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValuesOrThrow(
-        depKeys, exceptionClass1, exceptionClass2, exceptionClass3, exceptionClass4);
-  }
-
-  @Override
-  public <
-          E1 extends Exception,
-          E2 extends Exception,
-          E3 extends Exception,
-          E4 extends Exception,
-          E5 extends Exception>
-      Map<SkyKey, ValueOrException5<E1, E2, E3, E4, E5>> getValuesOrThrow(
-          Iterable<? extends SkyKey> depKeys,
-          Class<E1> exceptionClass1,
-          Class<E2> exceptionClass2,
-          Class<E3> exceptionClass3,
-          Class<E4> exceptionClass4,
-          Class<E5> exceptionClass5)
-          throws InterruptedException {
-    recordDeps(depKeys);
-    return delegate.getValuesOrThrow(
-        depKeys,
-        exceptionClass1,
-        exceptionClass2,
-        exceptionClass3,
-        exceptionClass4,
-        exceptionClass5);
-  }
-
-  @Override
-  public boolean valuesMissing() {
-    return delegate.valuesMissing();
-  }
-
-  @Override
-  public ExtendedEventHandler getListener() {
-    return delegate.getListener();
-  }
-
-  @Override
-  public boolean inErrorBubblingForTesting() {
-    return delegate.inErrorBubblingForTesting();
-  }
-
-  @Nullable
-  @Override
-  public GroupedList<SkyKey> getTemporaryDirectDeps() {
-    return delegate.getTemporaryDirectDeps();
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkIntegrationTest.java b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkIntegrationTest.java
index 7f6958a4c5..78fd333fae 100644
--- a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkIntegrationTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkIntegrationTest.java
@@ -1652,7 +1652,6 @@ public class SkylarkIntegrationTest extends BuildViewTestCase {
               .getSkyFunctionsForTesting();
       SkylarkImportLookupFunction skylarkImportLookupFunction =
           new SkylarkImportLookupFunction(this.getRuleClassProvider(), this.getPackageFactory());
-      skylarkImportLookupFunction.resetCache();
       ((PackageFunction) skyFunctions.get(SkyFunctions.PACKAGE))
           .setSkylarkImportLookupFunctionForInliningForTesting(skylarkImportLookupFunction);
     }