Pass AndroidDataContext through manifest processing methods

Manifest processing methods are particularly messy for this migration, since
the old ApplicationManifest class is still around. Anyway, pass around
AndroidDataContext instead of RuleContext everywhere we can.

Note that the built-in expander does not seem able to be modified to support
decoupling attributes and other information, and thus really can't be done once
we get rid of RuleContext. Instead, for Skylark rules, document that expansion
must happen outside of the Android data Skylark method calls (for example, for
manifest_values and nocompress_extensions).

RELNOTES: none
PiperOrigin-RevId: 197567541

11 files changed, 237 insertions, 212 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/analysis/actions/FileWriteAction.java b/src/main/java/com/google/devtools/build/lib/analysis/actions/FileWriteAction.java
index 5a75dffc0e..f2d14f1323 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/actions/FileWriteAction.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/actions/FileWriteAction.java
@@ -149,16 +149,19 @@ public final class FileWriteAction extends AbstractFileWriteAction {
    * Creates a new FileWriteAction instance.
    *
    * <p>There are no inputs. Transparent compression is controlled by the {@code
-   * --experimental_transparent_compression} flag. No reference to the {@link RuleContext} will be
-   * maintained.
+   * --experimental_transparent_compression} flag. No reference to the {@link
+   * ActionConstructionContext} will be maintained.
    *
-   * @param context the rule context
+   * @param context the action construction context
    * @param output the Artifact that will be created by executing this Action
    * @param fileContents the contents to be written to the file
    * @param makeExecutable whether the output file is made executable
    */
   public static FileWriteAction create(
-      RuleContext context, Artifact output, CharSequence fileContents, boolean makeExecutable) {
+      ActionConstructionContext context,
+      Artifact output,
+      CharSequence fileContents,
+      boolean makeExecutable) {
     return new FileWriteAction(
         context.getActionOwner(),
         Artifact.NO_ARTIFACTS,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidBinary.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidBinary.java
index 43805cd013..b023c46031 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidBinary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidBinary.java
@@ -202,7 +202,12 @@ public abstract class AndroidBinary implements RuleConfiguredTargetFactory {
 
     if (AndroidResources.decoupleDataProcessing(dataContext)) {
       StampedAndroidManifest manifest =
-          AndroidManifest.fromAttributes(ruleContext, androidSemantics).mergeWithDeps(ruleContext);
+          AndroidManifest.fromAttributes(ruleContext, dataContext, androidSemantics)
+              .mergeWithDeps(
+                  dataContext,
+                  resourceDeps,
+                  ApplicationManifest.getManifestValues(ruleContext),
+                  ApplicationManifest.useLegacyMerging(ruleContext));
       applicationManifest =
           ApplicationManifest.fromExplicitManifest(ruleContext, manifest.getManifest());
 
@@ -237,7 +242,9 @@ public abstract class AndroidBinary implements RuleConfiguredTargetFactory {
               .generateRClass(dataContext, aaptVersion);
     } else {
       applicationManifest =
-          androidSemantics.getManifestForRule(ruleContext).mergeWith(ruleContext, resourceDeps);
+          androidSemantics
+              .getManifestForRule(ruleContext)
+              .mergeWith(ruleContext, dataContext, resourceDeps);
 
       Artifact featureOfArtifact =
           ruleContext.attributes().isAttributeValueExplicitlySpecified("feature_of")
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLibrary.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLibrary.java
index 924d3ae911..67dbd5a85e 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLibrary.java
@@ -150,7 +150,8 @@ public abstract class AndroidLibrary implements RuleConfiguredTargetFactory {
     if (definesLocalResources) {
       if (androidConfig.decoupleDataProcessing()) {
         StampedAndroidManifest manifest =
-            AndroidManifest.fromAttributes(ruleContext, androidSemantics).stamp(ruleContext);
+            AndroidManifest.fromAttributes(ruleContext, dataContext, androidSemantics)
+                .stamp(dataContext);
 
         ValidatedAndroidResources resources =
             AndroidResources.from(ruleContext, "resource_files")
@@ -164,7 +165,7 @@ public abstract class AndroidLibrary implements RuleConfiguredTargetFactory {
         ApplicationManifest applicationManifest =
             androidSemantics
                 .getManifestForRule(ruleContext)
-                .renamePackage(ruleContext, AndroidCommon.getJavaPackage(ruleContext));
+                .renamePackage(dataContext, AndroidCommon.getJavaPackage(ruleContext));
         resourceApk =
             applicationManifest.packLibraryWithDataAndResources(
                 ruleContext,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBase.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBase.java
index 884c89d998..5d4e3ee9ec 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBase.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidLocalTestBase.java
@@ -97,7 +97,7 @@ public abstract class AndroidLocalTestBase implements RuleConfiguredTargetFactor
       resourceApk =
           buildResourceApk(
               dataContext,
-              AndroidManifest.fromAttributes(ruleContext),
+              AndroidManifest.fromAttributes(ruleContext, dataContext),
               AndroidResources.from(ruleContext, "resource_files"),
               AndroidAssets.from(ruleContext),
               ResourceDependencies.fromRuleDeps(ruleContext, /* neverlink = */ false),
@@ -110,7 +110,7 @@ public abstract class AndroidLocalTestBase implements RuleConfiguredTargetFactor
           ResourceDependencies.fromRuleDeps(ruleContext, /* neverlink= */ false);
 
       ApplicationManifest applicationManifest =
-          getApplicationManifest(ruleContext, resourceDependencies);
+          getApplicationManifest(ruleContext, dataContext, resourceDependencies);
 
       // Create the final merged R class
       resourceApk =
@@ -410,18 +410,21 @@ public abstract class AndroidLocalTestBase implements RuleConfiguredTargetFactor
    * @throws RuleErrorException
    */
   private ApplicationManifest getApplicationManifest(
-      RuleContext ruleContext, ResourceDependencies resourceDependencies)
+      RuleContext ruleContext,
+      AndroidDataContext dataContext,
+      ResourceDependencies resourceDependencies)
       throws InterruptedException, RuleErrorException {
     ApplicationManifest applicationManifest;
 
     if (AndroidResources.definesAndroidResources(ruleContext.attributes())) {
       AndroidResources.validateRuleContext(ruleContext);
-      ApplicationManifest ruleManifest = ApplicationManifest.renamedFromRule(ruleContext);
-      applicationManifest = ruleManifest.mergeWith(ruleContext, resourceDependencies);
+      ApplicationManifest ruleManifest =
+          ApplicationManifest.renamedFromRule(ruleContext, dataContext);
+      applicationManifest = ruleManifest.mergeWith(ruleContext, dataContext, resourceDependencies);
     } else {
       // we don't have a manifest, merge like android_library with a stub manifest
       ApplicationManifest dummyManifest = ApplicationManifest.generatedManifest(ruleContext);
-      applicationManifest = dummyManifest.mergeWith(ruleContext, resourceDependencies);
+      applicationManifest = dummyManifest.mergeWith(ruleContext, dataContext, resourceDependencies);
     }
     return applicationManifest;
   }
@@ -553,10 +556,7 @@ public abstract class AndroidLocalTestBase implements RuleConfiguredTargetFactor
 
     StampedAndroidManifest stamped =
         manifest.mergeWithDeps(
-            dataContext.getRuleContext(),
-            resourceDeps,
-            manifestValues,
-            /* useLegacyMerger = */ false);
+            dataContext, resourceDeps, manifestValues, /* useLegacyMerger = */ false);
 
     return ProcessedAndroidData.processLocalTestDataFrom(
             dataContext,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidManifest.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidManifest.java
index 9b98259822..16920df0b0 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidManifest.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidManifest.java
@@ -15,8 +15,10 @@ package com.google.devtools.build.lib.rules.android;
 
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.actions.ActionConstructionContext;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
 import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
+import com.google.devtools.build.lib.packages.RuleErrorConsumer;
 import com.google.devtools.build.lib.rules.java.JavaUtil;
 import com.google.devtools.build.lib.syntax.Type;
 import com.google.devtools.build.lib.vfs.PathFragment;
@@ -32,6 +34,7 @@ public class AndroidManifest {
   private final Artifact manifest;
   /** The Android package. Will be null if and only if this is an aar_import target. */
   @Nullable private final String pkg;
+
   private final boolean exported;
 
   public static StampedAndroidManifest forAarImport(Artifact manifest) {
@@ -43,13 +46,15 @@ public class AndroidManifest {
    *
    * <p>If no manifest is specified in the rule's attributes, an empty manifest will be generated.
    *
-   * <p>Unlike {@link #fromAttributes(RuleContext, AndroidSemantics)}, the AndroidSemantics-specific
-   * manifest processing methods will not be applied in this method. The manifest returned by this
-   * method will be the same regardless of the AndroidSemantics being used.
+   * <p>Unlike {@link #fromAttributes(RuleContext, AndroidDataContext,AndroidSemantics)}, the
+   * AndroidSemantics-specific manifest processing methods will not be applied in this method. The
+   * manifest returned by this method will be the same regardless of the AndroidSemantics being
+   * used.
    */
-  public static AndroidManifest fromAttributes(RuleContext ruleContext)
+  public static AndroidManifest fromAttributes(
+      RuleContext ruleContext, AndroidDataContext dataContext)
       throws InterruptedException, RuleErrorException {
-    return fromAttributes(ruleContext, null);
+    return fromAttributes(ruleContext, dataContext, null);
   }
 
   /**
@@ -60,10 +65,11 @@ public class AndroidManifest {
    * <p>If a non-null {@link AndroidSemantics} is passed, AndroidSemantics-specific manifest
    * processing will be preformed on this manifest. Otherwise, basic manifest renaming will be
    * performed if needed.
-   *
    */
   public static AndroidManifest fromAttributes(
-      RuleContext ruleContext, @Nullable AndroidSemantics androidSemantics)
+      RuleContext ruleContext,
+      AndroidDataContext dataContext,
+      @Nullable AndroidSemantics androidSemantics)
       throws RuleErrorException, InterruptedException {
     Artifact rawManifest = null;
     if (AndroidResources.definesAndroidResources(ruleContext.attributes())) {
@@ -72,6 +78,7 @@ public class AndroidManifest {
     }
 
     return from(
+        dataContext,
         ruleContext,
         rawManifest,
         androidSemantics,
@@ -82,21 +89,22 @@ public class AndroidManifest {
   /**
    * Creates an AndroidManifest object, with correct preprocessing, from explicit variables.
    *
-   * <p>Attributes included in the RuleContext will not be used; use {@link #from(RuleContext)}
-   * instead.
+   * <p>Attributes included in the RuleContext will not be used; use {@link
+   * #fromAttributes(RuleContext, AndroidDataContext)} instead.
    *
    * <p>In addition, the AndroidSemantics-specific manifest processing methods will not be applied
    * in this method. The manifest returned by this method will be the same regardless of the
-   * AndroidSemantics being used. use {@link #from(RuleContext, AndroidSemantics)} instead if you
-   * want AndroidSemantics-specific behavior.
+   * AndroidSemantics being used. use {@link #fromAttributes(RuleContext, AndroidDataContext,
+   * AndroidSemantics)} instead if you want AndroidSemantics-specific behavior.
    */
   public static AndroidManifest from(
-      RuleContext ruleContext,
+      AndroidDataContext dataContext,
+      RuleErrorConsumer errorConsumer,
       @Nullable Artifact rawManifest,
       @Nullable String pkg,
       boolean exportsManifest)
       throws InterruptedException {
-    return from(ruleContext, rawManifest, null, pkg, exportsManifest);
+    return from(dataContext, errorConsumer, rawManifest, null, pkg, exportsManifest);
   }
 
   /**
@@ -105,26 +113,28 @@ public class AndroidManifest {
    * <p>AndroidSemantics-specific processing will be used if a non-null AndroidSemantics is passed.
    */
   static AndroidManifest from(
-      RuleContext ruleContext,
+      AndroidDataContext dataContext,
+      RuleErrorConsumer errorConsumer,
       @Nullable Artifact rawManifest,
       @Nullable AndroidSemantics androidSemantics,
       @Nullable String pkg,
       boolean exportsManifest)
       throws InterruptedException {
     if (pkg == null) {
-      pkg = getDefaultPackage(ruleContext);
+      pkg = getDefaultPackage(dataContext.getActionConstructionContext(), errorConsumer);
     }
 
     if (rawManifest == null) {
       // Generate a dummy manifest
-      return StampedAndroidManifest.createEmpty(ruleContext, pkg, /* exported = */ false);
+      return StampedAndroidManifest.createEmpty(
+          dataContext.getActionConstructionContext(), pkg, /* exported = */ false);
     }
 
     Artifact renamedManifest;
     if (androidSemantics != null) {
-      renamedManifest = androidSemantics.renameManifest(ruleContext, rawManifest);
+      renamedManifest = androidSemantics.renameManifest(dataContext, rawManifest);
     } else {
-      renamedManifest = ApplicationManifest.renameManifestIfNeeded(ruleContext, rawManifest);
+      renamedManifest = ApplicationManifest.renameManifestIfNeeded(dataContext, rawManifest);
     }
 
     return new AndroidManifest(renamedManifest, pkg, exportsManifest);
@@ -136,7 +146,7 @@ public class AndroidManifest {
 
   /**
    * Creates a manifest wrapper without doing any processing. From within a rule, use {@link
-   * #from(RuleContext, AndroidSemantics)} instead.
+   * #fromAttributes(RuleContext, AndroidDataContext, AndroidSemantics)} instead.
    */
   public AndroidManifest(Artifact manifest, @Nullable String pkg, boolean exported) {
     this.manifest = manifest;
@@ -145,9 +155,9 @@ public class AndroidManifest {
   }
 
   /** If needed, stamps the manifest with the correct Java package */
-  public StampedAndroidManifest stamp(RuleContext ruleContext) {
+  public StampedAndroidManifest stamp(AndroidDataContext dataContext) {
     return new StampedAndroidManifest(
-        ApplicationManifest.maybeSetManifestPackage(ruleContext, manifest, pkg).orElse(manifest),
+        ApplicationManifest.maybeSetManifestPackage(dataContext, manifest, pkg).orElse(manifest),
         pkg,
         exported);
   }
@@ -157,39 +167,31 @@ public class AndroidManifest {
    *
    * <p>If no manifest values are specified, the manifest will remain unstamped.
    */
-  public StampedAndroidManifest stampWithManifestValues(RuleContext ruleContext) {
+  public StampedAndroidManifest stampWithManifestValues(
+      RuleContext ruleContext, AndroidDataContext dataContext) {
     return mergeWithDeps(
-        ruleContext,
+        dataContext,
         ResourceDependencies.empty(),
         ApplicationManifest.getManifestValues(ruleContext),
         ApplicationManifest.useLegacyMerging(ruleContext));
   }
 
   /**
-   * Merges the manifest with any dependent manifests, extracted from rule attributes.
+   * Merges the manifest with any dependent manifests
    *
-   * <p>The manifest will also be stamped with any manifest values specified in the target's
-   * attributes
+   * <p>The manifest will also be stamped with any manifest values specified
    *
    * <p>If there is no merging to be done and no manifest values are specified, the manifest will
    * remain unstamped.
    */
-  public StampedAndroidManifest mergeWithDeps(RuleContext ruleContext) {
-    return mergeWithDeps(
-        ruleContext,
-        ResourceDependencies.fromRuleDeps(ruleContext, /* neverlink = */ false),
-        ApplicationManifest.getManifestValues(ruleContext),
-        ApplicationManifest.useLegacyMerging(ruleContext));
-  }
-
   public StampedAndroidManifest mergeWithDeps(
-      RuleContext ruleContext,
+      AndroidDataContext dataContext,
       ResourceDependencies resourceDeps,
       Map<String, String> manifestValues,
       boolean useLegacyMerger) {
     Artifact newManifest =
         ApplicationManifest.maybeMergeWith(
-            ruleContext, manifest, resourceDeps, manifestValues, useLegacyMerger, pkg)
+                dataContext, manifest, resourceDeps, manifestValues, useLegacyMerger, pkg)
             .orElse(manifest);
 
     return new StampedAndroidManifest(newManifest, pkg, exported);
@@ -214,13 +216,14 @@ public class AndroidManifest {
       return ruleContext.attributes().get(CUSTOM_PACKAGE_ATTR, Type.STRING);
     }
 
-    return getDefaultPackage(ruleContext);
+    return getDefaultPackage(ruleContext, ruleContext);
   }
 
   /** Gets the default Java package */
-  public static String getDefaultPackage(RuleContext ruleContext) {
-    PathFragment dummyJar = ruleContext.getPackageDirectory().getChild("Dummy.jar");
-    return getJavaPackageFromPath(ruleContext, dummyJar);
+  public static String getDefaultPackage(
+      ActionConstructionContext context, RuleErrorConsumer errorConsumer) {
+    PathFragment dummyJar = context.getPackageDirectory().getChild("Dummy.jar");
+    return getJavaPackageFromPath(context, errorConsumer, dummyJar);
   }
 
   /**
@@ -230,21 +233,23 @@ public class AndroidManifest {
    * or "javatests" followed by the Java package; this method validates and takes advantage of that
    * requirement.
    *
-   * @param ruleContext the current context
    * @param jarPathFragment The path to a JAR file contained in the current BUILD file's directory.
    * @return the Java package, as a String
    */
-  static String getJavaPackageFromPath(RuleContext ruleContext, PathFragment jarPathFragment) {
+  static String getJavaPackageFromPath(
+      ActionConstructionContext context,
+      RuleErrorConsumer errorConsumer,
+      PathFragment jarPathFragment) {
     // TODO(bazel-team): JavaUtil.getJavaPackageName does not check to see if the path is valid.
     // So we need to check for the JavaRoot.
     if (JavaUtil.getJavaRoot(jarPathFragment) == null) {
-      ruleContext.ruleError(
+      errorConsumer.ruleError(
           "The location of your BUILD file determines the Java package used for "
               + "Android resource processing. A directory named \"java\" or \"javatests\" will "
               + "be used as your Java source root and the path of your BUILD file relative to "
               + "the Java source root will be used as the package for Android resource "
               + "processing. The Java source root could not be determined for \""
-              + ruleContext.getPackageDirectory()
+              + context.getPackageDirectory()
               + "\". Move your BUILD file under a java or javatests directory, or set the "
               + "'custom_package' attribute.");
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSemantics.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSemantics.java
index 0bdb85ed89..ae8fa2fe65 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSemantics.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSemantics.java
@@ -41,12 +41,12 @@ public interface AndroidSemantics {
       throws InterruptedException, RuleErrorException {
     Artifact rawManifest = ApplicationManifest.getManifestFromAttributes(ruleContext);
     return ApplicationManifest.fromExplicitManifest(
-        ruleContext, renameManifest(ruleContext, rawManifest));
+        ruleContext, renameManifest(makeContextForNative(ruleContext), rawManifest));
   }
 
-  default Artifact renameManifest(RuleContext ruleContext, Artifact rawManifest)
+  default Artifact renameManifest(AndroidDataContext dataContext, Artifact rawManifest)
       throws InterruptedException {
-    return ApplicationManifest.renameManifestIfNeeded(ruleContext, rawManifest);
+    return ApplicationManifest.renameManifestIfNeeded(dataContext, rawManifest);
   }
 
   /** Returns the name of the file in which the file names of native dependencies are listed. */
@@ -94,13 +94,12 @@ public interface AndroidSemantics {
   ImmutableList<String> getAttributesWithJavaRuntimeDeps(RuleContext ruleContext);
 
   /** A hook for checks of internal-only or external-only attributes of {@code android_binary}. */
-  default void validateAndroidBinaryRuleContext(RuleContext ruleContext) throws RuleErrorException {
-  }
+  default void validateAndroidBinaryRuleContext(RuleContext ruleContext)
+      throws RuleErrorException {}
 
   /** A hook for checks of internal-only or external-only attributes of {@code android_library}. */
   default void validateAndroidLibraryRuleContext(RuleContext ruleContext)
-      throws RuleErrorException {
-  }
+      throws RuleErrorException {}
 
   /** The artifact for the map that proguard will output. */
   Artifact getProguardOutputMap(RuleContext ruleContext) throws InterruptedException;
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSkylarkData.java b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSkylarkData.java
index 00094910e3..c89d3c9a8e 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSkylarkData.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/AndroidSkylarkData.java
@@ -122,6 +122,8 @@ public abstract class AndroidSkylarkData {
                     + " file, will be used. For example, given a BUILD file in"
                     + " 'java/com/foo/bar/BUILD', the package would be 'com.foo.bar'."),
       },
+      useLocation = true,
+      useEnvironment = true,
       doc =
           "Creates an AndroidResourcesInfo from this target's resource dependencies, ignoring local"
               + " resources. Only processing of deps will be done. This method is deprecated and"
@@ -132,18 +134,24 @@ public abstract class AndroidSkylarkData {
       AndroidDataContext ctx,
       SkylarkList<AndroidResourcesInfo> deps,
       boolean neverlink,
-      Object customPackage)
-      throws InterruptedException {
-    String pkg = fromNoneable(customPackage, String.class);
-    if (pkg == null) {
-      pkg = AndroidManifest.getDefaultPackage(ctx.getRuleContext());
+      Object customPackage,
+      Location location,
+      Environment env)
+      throws InterruptedException, EvalException {
+    try (SkylarkErrorReporter errorReporter =
+        SkylarkErrorReporter.from(ctx.getActionConstructionContext(), location, env)) {
+      String pkg = fromNoneable(customPackage, String.class);
+      if (pkg == null) {
+        pkg = AndroidManifest.getDefaultPackage(ctx.getActionConstructionContext(), errorReporter);
+      }
+      return ResourceApk.processFromTransitiveLibraryData(
+              ctx,
+              ResourceDependencies.fromProviders(deps, /* neverlink = */ neverlink),
+              AssetDependencies.empty(),
+              StampedAndroidManifest.createEmpty(
+                  ctx.getActionConstructionContext(), pkg, /* exported = */ false))
+          .toResourceInfo(ctx.getLabel());
     }
-    return ResourceApk.processFromTransitiveLibraryData(
-            ctx,
-            ResourceDependencies.fromProviders(deps, /* neverlink = */ neverlink),
-            AssetDependencies.empty(),
-            StampedAndroidManifest.createEmpty(ctx.getRuleContext(), pkg, /* exported = */ false))
-        .toResourceInfo(ctx.getLabel());
   }
 
   @SkylarkCallable(
@@ -181,27 +189,35 @@ public abstract class AndroidSkylarkData {
                     + " eventually merged into targets that depend on it. Otherwise, it won't be"
                     + " inherited."),
       },
+      useLocation = true,
+      useEnvironment = true,
       doc = "Stamps a manifest with package information.")
   public AndroidManifestInfo stampAndroidManifest(
-      AndroidDataContext ctx, Object manifest, Object customPackage, boolean exported)
-      throws InterruptedException {
+      AndroidDataContext ctx,
+      Object manifest,
+      Object customPackage,
+      boolean exported,
+      Location location,
+      Environment env)
+      throws InterruptedException, EvalException {
     String pkg = fromNoneable(customPackage, String.class);
-    if (pkg == null) {
-      pkg = AndroidManifest.getDefaultPackage(ctx.getRuleContext());
+    try (SkylarkErrorReporter errorReporter =
+        SkylarkErrorReporter.from(ctx.getActionConstructionContext(), location, env)) {
+      if (pkg == null) {
+        pkg = AndroidManifest.getDefaultPackage(ctx.getActionConstructionContext(), errorReporter);
+      }
     }
 
     Artifact primaryManifest = fromNoneable(manifest, Artifact.class);
     if (primaryManifest == null) {
-      return StampedAndroidManifest.createEmpty(ctx.getRuleContext(), pkg, exported).toProvider();
+      return StampedAndroidManifest.createEmpty(ctx.getActionConstructionContext(), pkg, exported)
+          .toProvider();
     }
 
     // If needed, rename the manifest to "AndroidManifest.xml", which aapt expects.
-    Artifact renamedManifest =
-        getAndroidSemantics().renameManifest(ctx.getRuleContext(), primaryManifest);
+    Artifact renamedManifest = getAndroidSemantics().renameManifest(ctx, primaryManifest);
 
-    return new AndroidManifest(renamedManifest, pkg, exported)
-        .stamp(ctx.getRuleContext())
-        .toProvider();
+    return new AndroidManifest(renamedManifest, pkg, exported).stamp(ctx).toProvider();
   }
 
   @SkylarkCallable(
@@ -613,7 +629,7 @@ public abstract class AndroidSkylarkData {
 
       // If none of these parameters were specified, for backwards compatibility, do not trigger
       // data processing.
-      resourcesInfo = resourcesFromDeps(ctx, resourceDeps, neverlink, customPackage);
+      resourcesInfo = resourcesFromDeps(ctx, resourceDeps, neverlink, customPackage, location, env);
       assetsInfo = assetsFromDeps(assetDeps, neverlink, env);
 
       infoBuilder.put(AndroidResourcesInfo.PROVIDER, resourcesInfo);
@@ -624,7 +640,9 @@ public abstract class AndroidSkylarkData {
               ctx,
               manifest,
               customPackage,
-              fromNoneableOrDefault(exportsManifest, Boolean.class, false));
+              fromNoneableOrDefault(exportsManifest, Boolean.class, false),
+              location,
+              env);
 
       SkylarkDict<NativeProvider<?>, NativeInfo> resourceOutput =
           mergeResources(
@@ -789,7 +807,9 @@ public abstract class AndroidSkylarkData {
             type = SkylarkDict.class,
             generic1 = String.class,
             named = true,
-            doc = "A dictionary of values to be overridden in the manifest."),
+            doc =
+                "A dictionary of values to be overridden in the manifest. You must expand any"
+                    + " templates in these values before they are passed to this function."),
         @Param(
             name = "deps",
             positional = false,
@@ -814,7 +834,7 @@ public abstract class AndroidSkylarkData {
       Object assetsDir,
       Object customPackage,
       String aaptVersionString,
-      SkylarkDict<String, String> rawManifestValues,
+      SkylarkDict<String, String> manifestValues,
       SkylarkList<ConfiguredTarget> deps,
       Location location,
       Environment env)
@@ -822,12 +842,13 @@ public abstract class AndroidSkylarkData {
     try (SkylarkErrorReporter errorReporter =
         SkylarkErrorReporter.from(ctx.getActionConstructionContext(), location, env)) {
 
-    AndroidManifest rawManifest =
-        AndroidManifest.from(
-            ctx.getRuleContext(),
-            fromNoneable(manifest, Artifact.class),
-            fromNoneable(customPackage, String.class),
-            /* exportsManifest = */ false);
+      AndroidManifest rawManifest =
+          AndroidManifest.from(
+              ctx,
+              errorReporter,
+              fromNoneable(manifest, Artifact.class),
+              fromNoneable(customPackage, String.class),
+              /* exportsManifest = */ false);
 
       ResourceApk resourceApk =
           AndroidLocalTestBase.buildResourceApk(
@@ -844,7 +865,7 @@ public abstract class AndroidSkylarkData {
                   getProviders(deps, AndroidResourcesInfo.PROVIDER), /* neverlink = */ false),
               AssetDependencies.fromProviders(
                   getProviders(deps, AndroidAssetsInfo.PROVIDER), /* neverlink = */ false),
-              ApplicationManifest.getManifestValues(ctx.getRuleContext(), rawManifestValues),
+              manifestValues,
               AndroidAaptVersion.chooseTargetAaptVersion(ctx, errorReporter, aaptVersionString));
 
       return getNativeInfosFrom(resourceApk, ctx.getLabel());
@@ -895,7 +916,9 @@ public abstract class AndroidSkylarkData {
             type = SkylarkList.class,
             generic1 = String.class,
             named = true,
-            doc = "A list of file extension to leave uncompressed in apk."),
+            doc =
+                "A list of file extension to leave uncompressed in apk. Templates must be expanded"
+                    + " before passing this value in."),
         @Param(
             name = "aapt_version",
             positional = false,
@@ -916,7 +939,7 @@ public abstract class AndroidSkylarkData {
       Object shrinkResources,
       SkylarkList<String> resourceConfigurationFilters,
       SkylarkList<String> densities,
-      SkylarkList<String> rawNoCompressExtensions,
+      SkylarkList<String> noCompressExtensions,
       String aaptVersionString,
       Location location,
       Environment env)
@@ -936,10 +959,7 @@ public abstract class AndroidSkylarkData {
         fromNoneableOrDefault(
             shrinkResources, Boolean.class, ctx.getAndroidConfig().useAndroidResourceShrinking()),
         ResourceFilterFactory.from(aaptVersion, resourceConfigurationFilters, densities),
-        ctx.getRuleContext()
-            .getExpander()
-            .withDataLocations()
-            .tokenized("nocompress_extensions", rawNoCompressExtensions));
+        noCompressExtensions.getImmutableList());
   }
 
   /**
@@ -1042,7 +1062,9 @@ public abstract class AndroidSkylarkData {
             type = SkylarkDict.class,
             generic1 = String.class,
             named = true,
-            doc = "A dictionary of values to be overridden in the manifest."),
+            doc =
+                "A dictionary of values to be overridden in the manifest. You must expand any"
+                    + " templates in the values before calling this function."),
         @Param(
             name = "deps",
             positional = false,
@@ -1101,7 +1123,7 @@ public abstract class AndroidSkylarkData {
       Object assetsDir,
       Object manifest,
       Object customPackage,
-      SkylarkDict<String, String> rawManifestValues,
+      SkylarkDict<String, String> manifestValues,
       SkylarkList<ConfiguredTarget> deps,
       String manifestMerger,
       Object maybeSettings,
@@ -1113,31 +1135,32 @@ public abstract class AndroidSkylarkData {
     try (SkylarkErrorReporter errorReporter =
         SkylarkErrorReporter.from(ctx.getActionConstructionContext(), location, env)) {
 
-    BinaryDataSettings settings =
-        fromNoneableOrDefault(
-            maybeSettings, BinaryDataSettings.class, defaultBinaryDataSettings(ctx, location, env));
+      BinaryDataSettings settings =
+          fromNoneableOrDefault(
+              maybeSettings,
+              BinaryDataSettings.class,
+              defaultBinaryDataSettings(ctx, location, env));
 
-    AndroidManifest rawManifest =
-        AndroidManifest.from(
-            ctx.getRuleContext(),
-            fromNoneable(manifest, Artifact.class),
-            getAndroidSemantics(),
-            fromNoneable(customPackage, String.class),
-            /* exportsManifest = */ false);
-
-    ResourceDependencies resourceDeps =
-        ResourceDependencies.fromProviders(
-            getProviders(deps, AndroidResourcesInfo.PROVIDER), /* neverlink = */ false);
-
-    ImmutableMap<String, String> manifestValues =
-        ApplicationManifest.getManifestValues(ctx.getRuleContext(), rawManifestValues);
-
-    StampedAndroidManifest stampedManifest =
-        rawManifest.mergeWithDeps(
-            ctx.getRuleContext(),
-            resourceDeps,
-            manifestValues,
-            ApplicationManifest.useLegacyMerging(ctx.getRuleContext(), manifestMerger));
+      AndroidManifest rawManifest =
+          AndroidManifest.from(
+              ctx,
+              errorReporter,
+              fromNoneable(manifest, Artifact.class),
+              getAndroidSemantics(),
+              fromNoneable(customPackage, String.class),
+              /* exportsManifest = */ false);
+
+      ResourceDependencies resourceDeps =
+          ResourceDependencies.fromProviders(
+              getProviders(deps, AndroidResourcesInfo.PROVIDER), /* neverlink = */ false);
+
+      StampedAndroidManifest stampedManifest =
+          rawManifest.mergeWithDeps(
+              ctx,
+              resourceDeps,
+              manifestValues,
+              ApplicationManifest.useLegacyMerging(
+                  errorReporter, ctx.getAndroidConfig(), manifestMerger));
 
       ResourceApk resourceApk =
           ProcessedAndroidData.processBinaryDataFrom(
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/ApplicationManifest.java b/src/main/java/com/google/devtools/build/lib/rules/android/ApplicationManifest.java
index a5d3be231f..b7662c02e4 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/ApplicationManifest.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/ApplicationManifest.java
@@ -22,6 +22,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedMap;
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.actions.ActionConstructionContext;
 import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
 import com.google.devtools.build.lib.analysis.actions.FileWriteAction;
 import com.google.devtools.build.lib.analysis.actions.SpawnAction;
@@ -30,6 +31,7 @@ import com.google.devtools.build.lib.analysis.config.CompilationMode;
 import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget.Mode;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
+import com.google.devtools.build.lib.packages.RuleErrorConsumer;
 import com.google.devtools.build.lib.rules.android.AndroidConfiguration.AndroidAaptVersion;
 import com.google.devtools.build.lib.rules.android.AndroidConfiguration.AndroidManifestMerger;
 import com.google.devtools.build.lib.rules.android.ResourceContainer.Builder.JavaPackageSource;
@@ -47,7 +49,7 @@ public final class ApplicationManifest {
   public ApplicationManifest createSplitManifest(
       RuleContext ruleContext, String splitName, boolean hasCode) {
     Artifact result = createSplitManifest(ruleContext, manifest, splitName, hasCode);
-    return new ApplicationManifest(ruleContext, result, targetAaptVersion);
+    return new ApplicationManifest(result, manifestValues, targetAaptVersion);
   }
 
   static Artifact createSplitManifest(
@@ -88,7 +90,7 @@ public final class ApplicationManifest {
   public ApplicationManifest addMobileInstallStubApplication(RuleContext ruleContext)
       throws InterruptedException {
     Artifact stubManifest = addMobileInstallStubApplication(ruleContext, manifest);
-    return new ApplicationManifest(ruleContext, stubManifest, targetAaptVersion);
+    return new ApplicationManifest(stubManifest, manifestValues, targetAaptVersion);
   }
 
   static Artifact addMobileInstallStubApplication(RuleContext ruleContext, Artifact manifest)
@@ -139,13 +141,14 @@ public final class ApplicationManifest {
    * regardless of the AndroidSemantics implementation being used; that method may do different work
    * depending on the implementation.
    */
-  public static ApplicationManifest renamedFromRule(RuleContext ruleContext)
+  public static ApplicationManifest renamedFromRule(
+      RuleContext ruleContext, AndroidDataContext dataContext)
       throws InterruptedException, RuleErrorException {
     return fromExplicitManifest(
-        ruleContext, renameManifestIfNeeded(ruleContext, getManifestFromAttributes(ruleContext)));
+        ruleContext, renameManifestIfNeeded(dataContext, getManifestFromAttributes(ruleContext)));
   }
 
-  static Artifact renameManifestIfNeeded(RuleContext ruleContext, Artifact manifest)
+  static Artifact renameManifestIfNeeded(AndroidDataContext dataContext, Artifact manifest)
       throws InterruptedException {
     if (manifest.getFilename().equals("AndroidManifest.xml")) {
       return manifest;
@@ -155,14 +158,13 @@ public final class ApplicationManifest {
        * AndroidManifest.xml to it. aapt requires the manifest to be named as such.
        */
       Artifact manifestSymlink =
-          ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_SYMLINKED_MANIFEST);
-      SymlinkAction symlinkAction =
+          dataContext.createOutputArtifact(AndroidRuleClasses.ANDROID_SYMLINKED_MANIFEST);
+      dataContext.registerAction(
           new SymlinkAction(
-              ruleContext.getActionOwner(),
+              dataContext.getActionConstructionContext().getActionOwner(),
               manifest,
               manifestSymlink,
-              "Renaming Android manifest for " + ruleContext.getLabel());
-      ruleContext.registerAction(symlinkAction);
+              "Renaming Android manifest for " + dataContext.getLabel()));
       return manifestSymlink;
     }
   }
@@ -170,7 +172,9 @@ public final class ApplicationManifest {
   public static ApplicationManifest fromExplicitManifest(RuleContext ruleContext, Artifact manifest)
       throws RuleErrorException {
     return new ApplicationManifest(
-        ruleContext, manifest, AndroidAaptVersion.chooseTargetAaptVersion(ruleContext));
+        manifest,
+        getManifestValues(ruleContext),
+        AndroidAaptVersion.chooseTargetAaptVersion(ruleContext));
   }
 
   /**
@@ -192,12 +196,10 @@ public final class ApplicationManifest {
    *
    * @return an artifact for the generated manifest
    */
-  public static Artifact generateManifest(RuleContext ruleContext, String manifestPackage) {
+  public static Artifact generateManifest(
+      ActionConstructionContext context, String manifestPackage) {
     Artifact generatedManifest =
-        ruleContext.getUniqueDirectoryArtifact(
-            ruleContext.getRule().getName() + "_generated",
-            PathFragment.create("AndroidManifest.xml"),
-            ruleContext.getBinOrGenfilesDirectory());
+        context.getUniqueDirectoryArtifact("_generated", "AndroidManifest.xml");
 
     String contents =
         Joiner.on("\n")
@@ -208,35 +210,21 @@ public final class ApplicationManifest {
                 "   <application>",
                 "   </application>",
                 "</manifest>");
-    ruleContext
-        .getAnalysisEnvironment()
-        .registerAction(
-            FileWriteAction.create(
-                ruleContext, generatedManifest, contents, /*makeExecutable=*/ false));
+    context.registerAction(
+        FileWriteAction.create(context, generatedManifest, contents, /*makeExecutable=*/ false));
     return generatedManifest;
   }
 
   /** Gets a map of manifest values from this rule's 'manifest_values' attribute */
-  static ImmutableMap<String, String> getManifestValues(RuleContext context) {
-    return getManifestValues(
-        context,
-        context.attributes().isAttributeValueExplicitlySpecified("manifest_values")
-            ? context.attributes().get("manifest_values", Type.STRING_DICT)
-            : null);
-  }
-
-  /** Gets and expands an expanded map of manifest values from some raw map of manifest values. */
-  static ImmutableMap<String, String> getManifestValues(
-      RuleContext ruleContext, @Nullable Map<String, String> rawMap) {
+  public static ImmutableMap<String, String> getManifestValues(RuleContext context) {
     Map<String, String> manifestValues = new TreeMap<>();
-    if (rawMap != null) {
-      manifestValues.putAll(rawMap);
+    if (context.attributes().isAttributeValueExplicitlySpecified("manifest_values")) {
+      manifestValues.putAll(context.attributes().get("manifest_values", Type.STRING_DICT));
     }
 
     for (String variable : manifestValues.keySet()) {
       manifestValues.put(
-          variable,
-          ruleContext.getExpander().expand("manifest_values", manifestValues.get(variable)));
+          variable, context.getExpander().expand("manifest_values", manifestValues.get(variable)));
     }
     return ImmutableMap.copyOf(manifestValues);
   }
@@ -250,26 +238,29 @@ public final class ApplicationManifest {
   private final AndroidAaptVersion targetAaptVersion;
 
   private ApplicationManifest(
-      RuleContext ruleContext, Artifact manifest, AndroidAaptVersion targetAaptVersion) {
+      Artifact manifest,
+      ImmutableMap<String, String> manifestValues,
+      AndroidAaptVersion targetAaptVersion) {
     this.manifest = manifest;
-    this.manifestValues = getManifestValues(ruleContext);
+    this.manifestValues = manifestValues;
     this.targetAaptVersion = targetAaptVersion;
   }
 
-  public ApplicationManifest mergeWith(RuleContext ruleContext, ResourceDependencies resourceDeps) {
+  public ApplicationManifest mergeWith(
+      RuleContext ruleContext, AndroidDataContext dataContext, ResourceDependencies resourceDeps) {
     return maybeMergeWith(
-            ruleContext,
+            dataContext,
             manifest,
             resourceDeps,
             manifestValues,
             useLegacyMerging(ruleContext),
             AndroidCommon.getJavaPackage(ruleContext))
-        .map(merged -> new ApplicationManifest(ruleContext, merged, targetAaptVersion))
+        .map(merged -> new ApplicationManifest(merged, manifestValues, targetAaptVersion))
         .orElse(this);
   }
 
   static Optional<Artifact> maybeMergeWith(
-      RuleContext ruleContext,
+      AndroidDataContext dataContext,
       Artifact primaryManifest,
       ResourceDependencies resourceDeps,
       Map<String, String> manifestValues,
@@ -281,12 +272,9 @@ public final class ApplicationManifest {
       if (!mergeeManifests.isEmpty()) {
 
         Artifact outputManifest =
-            ruleContext.getUniqueDirectoryArtifact(
-                ruleContext.getRule().getName() + "_merged",
-                "AndroidManifest.xml",
-                ruleContext.getBinOrGenfilesDirectory());
+            dataContext.getUniqueDirectoryArtifact("_merged", "AndroidManifest.xml");
         AndroidManifestMergeHelper.createMergeManifestAction(
-            ruleContext,
+            dataContext.getRuleContext(),
             primaryManifest,
             mergeeManifests.keySet(),
             ImmutableList.of("all"),
@@ -296,16 +284,10 @@ public final class ApplicationManifest {
     } else {
       if (!mergeeManifests.isEmpty() || !manifestValues.isEmpty()) {
         Artifact outputManifest =
-            ruleContext.getUniqueDirectoryArtifact(
-                ruleContext.getRule().getName() + "_merged",
-                "AndroidManifest.xml",
-                ruleContext.getBinOrGenfilesDirectory());
+            dataContext.getUniqueDirectoryArtifact("_merged", "AndroidManifest.xml");
         Artifact mergeLog =
-            ruleContext.getUniqueDirectoryArtifact(
-                ruleContext.getRule().getName() + "_merged",
-                "manifest_merger_log.txt",
-                ruleContext.getBinOrGenfilesDirectory());
-        new ManifestMergerActionBuilder(ruleContext)
+            dataContext.getUniqueDirectoryArtifact("_merged", "manifest_merger_log.txt");
+        new ManifestMergerActionBuilder(dataContext.getRuleContext())
             .setManifest(primaryManifest)
             .setMergeeManifests(mergeeManifests)
             .setLibrary(false)
@@ -313,7 +295,7 @@ public final class ApplicationManifest {
             .setCustomPackage(customPackage)
             .setManifestOutput(outputManifest)
             .setLogOut(mergeLog)
-            .build(ruleContext);
+            .build(dataContext.getActionConstructionContext());
         return Optional.of(outputManifest);
       }
     }
@@ -321,23 +303,29 @@ public final class ApplicationManifest {
   }
 
   /** Checks if the legacy manifest merger should be used, based on a rule attribute */
-  static boolean useLegacyMerging(RuleContext ruleContext) {
+  public static boolean useLegacyMerging(RuleContext ruleContext) {
     return ruleContext.isLegalFragment(AndroidConfiguration.class)
         && ruleContext.getRule().isAttrDefined("manifest_merger", STRING)
-        && useLegacyMerging(ruleContext, ruleContext.attributes().get("manifest_merger", STRING));
+        && useLegacyMerging(
+            ruleContext,
+            AndroidCommon.getAndroidConfig(ruleContext),
+            ruleContext.attributes().get("manifest_merger", STRING));
   }
 
   /**
    * Checks if the legacy manifest merger should be used, based on an optional string specifying the
    * merger to use.
    */
-  public static boolean useLegacyMerging(RuleContext ruleContext, @Nullable String mergerString) {
+  public static boolean useLegacyMerging(
+      RuleErrorConsumer errorConsumer,
+      AndroidConfiguration androidConfig,
+      @Nullable String mergerString) {
     AndroidManifestMerger merger = AndroidManifestMerger.fromString(mergerString);
     if (merger == null) {
-      merger = ruleContext.getFragment(AndroidConfiguration.class).getManifestMerger();
+      merger = androidConfig.getManifestMerger();
     }
     if (merger == AndroidManifestMerger.LEGACY) {
-      ruleContext.ruleWarning(
+      errorConsumer.ruleWarning(
           "manifest_merger 'legacy' is deprecated. Please update to 'android'.\n"
               + "See https://developer.android.com/studio/build/manifest-merge.html for more "
               + "information about the manifest merger.");
@@ -358,32 +346,29 @@ public final class ApplicationManifest {
     return builder.build();
   }
 
-  public ApplicationManifest renamePackage(RuleContext ruleContext, String customPackage) {
-    Optional<Artifact> stamped = maybeSetManifestPackage(ruleContext, manifest, customPackage);
+  public ApplicationManifest renamePackage(AndroidDataContext dataContext, String customPackage) {
+    Optional<Artifact> stamped = maybeSetManifestPackage(dataContext, manifest, customPackage);
 
     if (!stamped.isPresent()) {
       return this;
     }
 
-    return new ApplicationManifest(ruleContext, stamped.get(), targetAaptVersion);
+    return new ApplicationManifest(stamped.get(), manifestValues, targetAaptVersion);
   }
 
   static Optional<Artifact> maybeSetManifestPackage(
-      RuleContext ruleContext, Artifact manifest, String customPackage) {
+      AndroidDataContext dataContext, Artifact manifest, String customPackage) {
     if (isNullOrEmpty(customPackage)) {
       return Optional.empty();
     }
     Artifact outputManifest =
-        ruleContext.getUniqueDirectoryArtifact(
-            ruleContext.getRule().getName() + "_renamed",
-            "AndroidManifest.xml",
-            ruleContext.getBinOrGenfilesDirectory());
-    new ManifestMergerActionBuilder(ruleContext)
+        dataContext.getUniqueDirectoryArtifact("_renamed", "AndroidManifest.xml");
+    new ManifestMergerActionBuilder(dataContext.getRuleContext())
         .setManifest(manifest)
         .setLibrary(true)
         .setCustomPackage(customPackage)
         .setManifestOutput(outputManifest)
-        .build(ruleContext);
+        .build(dataContext.getActionConstructionContext());
 
     return Optional.of(outputManifest);
   }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/ResourceContainer.java b/src/main/java/com/google/devtools/build/lib/rules/android/ResourceContainer.java
index a4972d208e..92055de918 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/ResourceContainer.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/ResourceContainer.java
@@ -341,7 +341,8 @@ public abstract class ResourceContainer implements ValidatedAndroidData {
         return ruleContext.attributes().get("custom_package", Type.STRING);
       }
 
-      return AndroidManifest.getJavaPackageFromPath(ruleContext, getJavaSourceJar().getExecPath());
+      return AndroidManifest.getJavaPackageFromPath(
+          ruleContext, ruleContext, getJavaSourceJar().getExecPath());
     }
 
     private static boolean hasCustomPackage(RuleContext ruleContext) {
diff --git a/src/main/java/com/google/devtools/build/lib/rules/android/StampedAndroidManifest.java b/src/main/java/com/google/devtools/build/lib/rules/android/StampedAndroidManifest.java
index 10e6ff4bab..a0ef0dd9d7 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/android/StampedAndroidManifest.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/android/StampedAndroidManifest.java
@@ -15,6 +15,7 @@ package com.google.devtools.build.lib.rules.android;
 
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.actions.ActionConstructionContext;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
 import javax.annotation.Nullable;
 
@@ -27,7 +28,7 @@ public class StampedAndroidManifest extends AndroidManifest {
   }
 
   @Override
-  public StampedAndroidManifest stamp(RuleContext ruleContext) {
+  public StampedAndroidManifest stamp(AndroidDataContext dataContext) {
     // This manifest is already stamped
     return this;
   }
@@ -53,9 +54,9 @@ public class StampedAndroidManifest extends AndroidManifest {
 
   /** Creates an empty manifest stamped with a specified package. */
   public static StampedAndroidManifest createEmpty(
-      RuleContext ruleContext, String pkg, boolean exported) {
+      ActionConstructionContext context, String pkg, boolean exported) {
     return new StampedAndroidManifest(
-        ApplicationManifest.generateManifest(ruleContext, pkg), pkg, exported);
+        ApplicationManifest.generateManifest(context, pkg), pkg, exported);
   }
 
   public StampedAndroidManifest addMobileInstallStubApplication(RuleContext ruleContext)
diff --git a/src/test/java/com/google/devtools/build/lib/rules/android/AndroidLibraryTest.java b/src/test/java/com/google/devtools/build/lib/rules/android/AndroidLibraryTest.java
index bc06435f46..6ba8585b01 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/android/AndroidLibraryTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/android/AndroidLibraryTest.java
@@ -1076,17 +1076,17 @@ public class AndroidLibraryTest extends AndroidBuildViewTestCase {
         "    srcs = ['foo.java'])");
 
     ConfiguredTarget target = getConfiguredTarget("//java/android:l");
-    Artifact manifest = getBinArtifact("l_generated/l/AndroidManifest.xml", target);
+    Artifact manifest = getBinArtifact("_generated/l/AndroidManifest.xml", target);
     FileWriteAction action = (FileWriteAction) getGeneratingAction(manifest);
     assertThat(action.getFileContents()).contains("package=\"android\"");
 
     target = getConfiguredTarget("//java/android:l2");
-    manifest = getBinArtifact("l2_generated/l2/AndroidManifest.xml", target);
+    manifest = getBinArtifact("_generated/l2/AndroidManifest.xml", target);
     action = (FileWriteAction) getGeneratingAction(manifest);
     assertThat(action.getFileContents()).contains("package=\"foo\"");
 
     target = getConfiguredTarget("//third_party/android:l");
-    manifest = getBinArtifact("l_generated/l/AndroidManifest.xml", target);
+    manifest = getBinArtifact("_generated/l/AndroidManifest.xml", target);
     action = (FileWriteAction) getGeneratingAction(manifest);
     assertThat(action.getFileContents()).contains("package=\"third_party.android\"");
   }