// Copyright 2015 Google Inc. 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 java

// This file generates the final rules for compiling all Java.  All properties related to
// compiling should have been translated into javaBuilderFlags or another argument to the Transform*
// functions.

import (
 "path/filepath"
 "slices"
 "strconv"
 "strings"

 "github.com/google/blueprint"
 "github.com/google/blueprint/proptools"

 "android/soong/android"
 "android/soong/remoteexec"
)

var (
 pctx = android.NewPackageContext("android/soong/java")

 mergeZips       = android.MergeZips
 zipSync         = android.ZipSync
 rm              = android.Rm
 mkdir           = android.Mkdir
 touch           = android.Touch
 splitZips       = pctx.HostTool("split_zips")
 extractApks     = pctx.HostTool("extract_apks")
 packageCheckCmd = pctx.HostTool("package_check")

 // Splits jars into a number of jars, with equal files in each output jar.
 splitSrcJars = pctx.AndroidStaticRule("javac-split-srcJars",
  blueprint.RuleParams{
   Command2:       blueprint.NewCommand(splitZips, ` -i "$rspFile" -f "*.java" $out`),
   Restat:         true,
   Rspfile:        "$rspFile",
   RspfileContent: "$in",
  }, "rspFile",
 )

 // Unzips java src files from supplied jars into a directory provided.
 extractSrcJars = pctx.AndroidStaticRule("javac-extract-srcJars",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    rm, ` -rf "$extractDir" && `,
    mkdir, ` -p "$extractDir" && `,
    zipSync, ` -d "$extractDir" -l "$out" -f "*.java" $jars`),
  }, "extractDir", "jars",
 )

 // Removes all outputs of inc-javac rule
 javacIncClean = pctx.AndroidStaticRule("javac-inc-partialcompileclean",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    android.Rm, ` -rf "${srcJarDir}" "${outDir}" "${annoDir}" "${annoSrcJar}" "${builtOut}"`,
   ),
  }, "srcJarDir", "outDir", "annoDir", "annoSrcJar", "builtOut",
 )

 // Incremental javac rule
 // The idea of this rule is to make javac incremental, i.e. use the input and
 // output of previous javac execution to reduce the src lists.
 // This rule is very similar to the normal javac rule with a few differences:
 // * Does not unzip srcJars in the rule
 // * Does not remove the temp directories containing classes/generated sources
 // * Saves the states of a bunch of input params, when javac executes successfully.
 // * Runs additional tools on the output to prepare for next iteration
 javacInc, javacIncRE = pctx.MultiCommandRemoteStaticRules("javac-inc",
  blueprint.RuleParams{
   Command: `rm -rf "$annoSrcJar.tmp" "$out.tmp" && ` +
    `mkdir -p "$annoDir" && ` +
    `if [ -s $out.rsp ] && [ -s $srcJarList ] ; then ` +
    `echo >> $out.rsp; fi && ` +
    `cat $srcJarList >> $out.rsp && ` +
    `if [ -s $genAnnoSrcJarList ] ; then ` +
    `echo >> $out.rsp && cat $genAnnoSrcJarList >> $out.rsp; fi && ` +
    `. ${config.UsePartialCompileFile} && ` +
    `${config.IncrementalJavacInputCmd} ` +
    `--srcs $out.rsp --classDir $outDir --deps $javacDeps --javacTarget $out --srcDepsProto $out.proto ` +
    `--localHeaderJars $localHeaderJars --crossModuleJarList $crossModuleJars --tool ${config.DependencyMapperJavacCmd} && ` +
    `mkdir -p "$outDir" && ` +
    `cat $out.rem.rsp | xargs rm -f && ` +
    `(if [ -s $out.inc.rsp ] ; then ` +
    `${config.SoongJavacWrapper} $javaTemplate${config.JavacCmd} ` +
    `${config.JavacHeapFlags} ${config.JavacVmFlags} ${config.CommonJdkFlags} ` +
    `$processorpath $processor $javacFlags $bootClasspath $classpath ` +
    `-source $javaVersion -target $javaVersion ` +
    `-d $outDir -s $annoDir @$out.inc.rsp ; fi ) && ` +
    `$annoSrcJarTemplate${config.SoongZipCmd} -jar -o $annoSrcJar.tmp -C $annoDir -D $annoDir && ` +
    `$zipTemplate${config.SoongZipCmd} -jar -o $out.tmp -C $outDir -D $outDir && ` +
    `if ! cmp -s "$out.tmp" "$out"; then mv "$out.tmp" "$out"; fi && ` +
    `if ! cmp -s "$annoSrcJar.tmp" "$annoSrcJar"; then mv "$annoSrcJar.tmp" "$annoSrcJar"; fi && ` +
    `if [ -f "$out.input.pc_state.new" ]; then mv "$out.input.pc_state.new" "$out.input.pc_state" && ` +
    `rm -rf $out.input.pc_state.new; fi && ` +
    `if [ -f "$out.deps.pc_state.new" ]; then mv "$out.deps.pc_state.new" "$out.deps.pc_state" && ` +
    `rm -rf $out.deps.pc_state.new; fi && ` +
    `if [ -f "$out.headers.pc_state.new" ]; then mv "$out.headers.pc_state.new" "$out.headers.pc_state" && ` +
    `rm -rf $out.headers.pc_state.new; fi && ` +
    `if [ -f "$out.crossModuleDeps.pc_state.new" ]; then mv "$out.crossModuleDeps.pc_state.new" "$out.crossModuleDeps.pc_state" && ` +
    `rm -rf $out.crossModuleDeps.pc_state.new; fi && ` +
    `if [ -f $out.rsp ] && [ -f $out ]; then ` +
    `${config.DependencyMapperJavacCmd} --src-path $out.rsp --jar-path $out --dependency-map-path $out.proto --cross-module-jar-list $crossModuleJars; fi`,
   CommandDeps: []string{
    "${config.DependencyMapperJavacCmd}",
    "${config.IncrementalJavacInputCmd}",
    "${config.JavacCmd}",
    "${config.ZipSyncCmd}",
   },
   CommandOrderOnly: []string{"${config.SoongJavacWrapper}"},
   Restat:           true,
   Rspfile:          "$out.rsp",
   RspfileContent:   "$in",
   SandboxDisabled:  true,
  }, map[string]*remoteexec.REParams{
   "$javaTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "compile", "lang": "java", "compiler": "javac"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
   "$zipTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "tool", "name": "soong_zip"},
    Inputs:       []string{"${config.SoongZipCmd}", "$outDir"},
    OutputFiles:  []string{"$out.tmp"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
   "$annoSrcJarTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "tool", "name": "soong_zip"},
    Inputs:       []string{"${config.SoongZipCmd}", "$annoDir"},
    OutputFiles:  []string{"$annoSrcJar.tmp"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
  }, []string{"javacFlags", "bootClasspath", "classpath", "processorpath", "processor", "srcJarList", "genAnnoSrcJarList",
   "outDir", "annoDir", "annoSrcJar", "javaVersion", "javacDeps", "localHeaderJars", "crossModuleJars"}, nil)

 // Compiling java is not conducive to proper dependency tracking.  The path-matches-class-name
 // requirement leads to unpredictable generated source file names, and a single .java file
 // will get compiled into multiple .class files if it contains inner classes.  To work around
 // this, all java rules write into separate directories and then are combined into a .jar file
 // (if the rule produces .class files) or a .srcjar file (if the rule produces .java files).
 // .srcjar files are unzipped into a temporary directory when compiled with javac.
 javac, javacRE = pctx.MultiCommandRemoteStaticRules("javac",
  blueprint.RuleParams{
   Command: `rm -rf "$outDir" "$annoDir" "$annoSrcJar.tmp" "$srcJarDir" "$out.tmp" && ` +
    `mkdir -p "$outDir" "$annoDir" "$srcJarDir" && ` +
    `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
    `${config.ZipSyncCmd} -d $annoDir -l $annoDir/list -f "*.java" $genAnnoSrcJars && ` +
    `(if [ -s $srcJarDir/list ] || [ -s $out.rsp ] || [ -s $annoDir/list ]; then ` +
    `${config.FindInputDeltaCmd} --template '' --target "$out" --inputs_file "$out.rsp" && ` +
    `${config.SoongJavacWrapper} $javaTemplate${config.JavacCmd} ` +
    `${config.JavacHeapFlags} ${config.JavacVmFlags} ${config.CommonJdkFlags} ` +
    `$processorpath $processor $javacFlags $bootClasspath $classpath ` +
    `-source $javaVersion -target $javaVersion ` +
    `-d $outDir -s $annoDir @$out.rsp @$srcJarDir/list @$annoDir/list ; fi ) && ` +
    `$annoSrcJarTemplate${config.SoongZipCmd} -jar -o $annoSrcJar.tmp -C $annoDir -D $annoDir && ` +
    `$zipTemplate${config.SoongZipCmd} -jar -o $out.tmp -C $outDir -D $outDir && ` +
    `if ! cmp -s "$out.tmp" "$out"; then mv "$out.tmp" "$out"; fi && ` +
    `if ! cmp -s "$annoSrcJar.tmp" "$annoSrcJar"; then mv "$annoSrcJar.tmp" "$annoSrcJar"; fi && ` +
    `if [ -f "$out.pc_state.new" ]; then mv "$out.pc_state.new" "$out.pc_state"; fi && ` +
    `rm -rf "$srcJarDir" "$outDir"`,
   CommandDeps: []string{
    "${config.FindInputDeltaCmd}",
    "${config.JavacCmd}",
    "${config.SoongZipCmd}",
    "${config.ZipSyncCmd}",
   },
   CommandOrderOnly: []string{"${config.SoongJavacWrapper}"},
   Restat:           true,
   Rspfile:          "$out.rsp",
   RspfileContent:   "$in",
   SandboxDisabled:  true,
  }, map[string]*remoteexec.REParams{
   "$javaTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "compile", "lang": "java", "compiler": "javac"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
   "$zipTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "tool", "name": "soong_zip"},
    Inputs:       []string{"${config.SoongZipCmd}", "$outDir"},
    OutputFiles:  []string{"$out.tmp"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
   "$annoSrcJarTemplate": &remoteexec.REParams{
    Labels:       map[string]string{"type": "tool", "name": "soong_zip"},
    Inputs:       []string{"${config.SoongZipCmd}", "$annoDir"},
    OutputFiles:  []string{"$annoSrcJar.tmp"},
    ExecStrategy: "${config.REJavacExecStrategy}",
    Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
   },
  }, []string{"javacFlags", "bootClasspath", "classpath", "processorpath", "processor", "srcJars", "srcJarDir",
   "outDir", "annoDir", "annoSrcJar", "genAnnoSrcJars", "javaVersion"}, nil)

 _ = pctx.VariableFunc("kytheCorpus",
  func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() })
 _ = pctx.VariableFunc("kytheCuEncoding",
  func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuEncoding() })
 _ = pctx.VariableFunc("kytheCuJavaSourceMax",
  func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuJavaSourceMax() })
 _ = pctx.SourcePathVariable("kytheVnames", "build/soong/vnames.json")
 // Run it with several --add-exports to allow the classes in the
 // com.google.devtools.kythe.extractors.java.standalone package access the packages in the
 // jdk.compiler compiler module. Long live Java modules.
 kytheExtract = pctx.AndroidStaticRule("kythe",
  blueprint.RuleParams{
   Command: `${config.ZipSyncCmd} -d $srcJarDir ` +
    `-l $srcJarDir/list -f "*.java" $srcJars && ` +
    `( [ ! -s $srcJarDir/list -a ! -s $out.rsp ] || ` +
    `KYTHE_ROOT_DIRECTORY=. KYTHE_OUTPUT_FILE=$out ` +
    `KYTHE_CORPUS=${kytheCorpus} ` +
    `KYTHE_VNAMES=${kytheVnames} ` +
    `KYTHE_KZIP_ENCODING=${kytheCuEncoding} ` +
    `KYTHE_JAVA_SOURCE_BATCH_SIZE=${kytheCuJavaSourceMax} ` +
    `${config.SoongJavacWrapper} ${config.JavaCmd} ` +
    // Avoid JDK9's warning about "Illegal reflective access by com.google.protobuf.Utf8$UnsafeProcessor ...
    // to field java.nio.Buffer.address"
    `--add-opens=java.base/java.nio=ALL-UNNAMED ` +
    // Allow the classes in the com.google.devtools.kythe.extractors.java.standalone package
    // access the packages in the jdk.compiler compiler module
    `--add-opens=java.base/java.nio=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED ` +
    `--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED ` +
    `--add-exports=jdk.internal.opt/jdk.internal.opt=ALL-UNNAMED ` +
    `-jar ${config.JavaKytheExtractorJar} ` +
    `${config.JavacHeapFlags} ${config.CommonJdkFlags} ` +
    `$processorpath $processor $javacFlags $bootClasspath ` +
    `-source $javaVersion -target $javaVersion ` +
    `-d $outDir -s $annoDir @$out.rsp @$srcJarDir/list)`,
   CommandDeps: []string{
    "${config.JavaCmd}",
    "${config.JavaKytheExtractorJar}",
    "${kytheVnames}",
    "${config.ZipSyncCmd}",
   },
   CommandOrderOnly: []string{"${config.SoongJavacWrapper}"},
   Rspfile:          "$out.rsp",
   RspfileContent:   "$classpath $in",
   SandboxDisabled:  true,
  },
  "javacFlags", "bootClasspath", "classpath", "processorpath", "processor", "srcJars", "srcJarDir",
  "outDir", "annoDir", "javaVersion")

 extractMatchingApks = pctx.StaticRule(
  "extractMatchingApks",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    rm, ` -rf "$out" && `,
    extractApks, ` -o "${out}" -zip "${zip}" -allow-prereleased=${allow-prereleased} `,
    `-sdk-version=${sdk-version} -skip-sdk-check=${skip-sdk-check} -abis=${abis} `,
    `--screen-densities=${screen-densities} --stem=${stem} `,
    `-apkcerts=${apkcerts} -partition=${partition} `,
    `${in}`),
  },
  "abis", "allow-prereleased", "screen-densities", "sdk-version", "skip-sdk-check", "stem", "apkcerts", "partition", "zip")

 turbine, turbineRE = pctx.RemoteStaticRules("turbine",
  blueprint.RuleParams{
   Command: `$reTemplate${config.JavaCmd} ${config.JavaVmFlags} -jar ${config.TurbineJar} $outputFlags ` +
    `--sources @$out.rsp ` +
    `--javacopts ${config.CommonJdkFlags} ` +
    `$javacFlags -source $javaVersion -target $javaVersion -- $turbineFlags && ` +
    `(for o in $outputs; do if cmp -s $${o}.tmp $${o} ; then rm $${o}.tmp ; else mv $${o}.tmp $${o} ; fi; done )`,
   CommandDeps: []string{
    "${config.TurbineJar}",
    "${config.JavaCmd}",
   },
   Rspfile:         "$out.rsp",
   RspfileContent:  "$in_newline",
   Restat:          true,
   SandboxDisabled: true,
  },
  &remoteexec.REParams{Labels: map[string]string{"type": "tool", "name": "turbine"},
   ExecStrategy:    "${config.RETurbineExecStrategy}",
   Inputs:          []string{"${config.TurbineJar}", "${out}.rsp", "$rbeInputs"},
   RSPFiles:        []string{"$out.rsp", "$rspFiles"},
   OutputFiles:     []string{"$rbeOutputs"},
   ToolchainInputs: []string{"${config.JavaCmd}"},
   Platform:        map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
  },
  []string{"javacFlags", "turbineFlags", "outputFlags", "javaVersion", "outputs", "rbeOutputs"}, []string{"rbeInputs", "rspFiles"})

 jar, jarRE = pctx.RemoteStaticRules("jar",
  blueprint.RuleParams{
   Command:         `$reTemplate${config.SoongZipCmd} -jar -o $out @$out.rsp`,
   CommandDeps:     []string{"${config.SoongZipCmd}"},
   Rspfile:         "$out.rsp",
   RspfileContent:  "$jarArgs",
   SandboxDisabled: true,
  },
  &remoteexec.REParams{
   ExecStrategy: "${config.REJarExecStrategy}",
   Inputs:       []string{"${config.SoongZipCmd}", "${out}.rsp"},
   RSPFiles:     []string{"$rspFiles"},
   OutputFiles:  []string{"$out"},
   Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
  }, []string{"jarArgs"}, []string{"rspFiles"})

 zip, zipRE = pctx.RemoteStaticRules("zip",
  blueprint.RuleParams{
   Command:         `${config.SoongZipCmd} -o $out @$out.rsp`,
   CommandDeps:     []string{"${config.SoongZipCmd}"},
   Rspfile:         "$out.rsp",
   RspfileContent:  "$jarArgs",
   SandboxDisabled: true,
  },
  &remoteexec.REParams{
   ExecStrategy: "${config.REZipExecStrategy}",
   Inputs:       []string{"${config.SoongZipCmd}", "${out}.rsp", "$implicits"},
   RSPFiles:     []string{"${out}.rsp"},
   OutputFiles:  []string{"$out"},
   Platform:     map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
  }, []string{"jarArgs"}, []string{"implicits"})

 combineJar = pctx.AndroidStaticRule("combineJar",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(mergeZips, ` --ignore-duplicates -j $jarArgs $out $in`),
  },
  "jarArgs")
 combineJarRsp = pctx.AndroidStaticRule("combineJarRsp",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    mergeZips, ` --ignore-duplicates -j $jarArgs $out @$out.rsp`),
   Rspfile:        "$out.rsp",
   RspfileContent: "$in",
  },
  "jarArgs")

 extractR8Rules = pctx.AndroidStaticRule("extractR8Rules",
  blueprint.RuleParams{
   Command:         `${config.ExtractR8RulesCmd} --rules-output $out --include-origin-comments $in`,
   CommandDeps:     []string{"${config.ExtractR8RulesCmd}"},
   SandboxDisabled: true,
  })

 jarjar = pctx.AndroidStaticRule("jarjar",
  blueprint.RuleParams{
   Command: "" +
    // Jarjar doesn't exit with an error when the rules file contains a syntax error,
    // leading to stale or missing files later in the build.  Remove the output file
    // before running jarjar.
    "rm -f ${out} && " +
    "${config.JavaCmd} ${config.JavaVmFlags}" +
    // b/146418363 Enable Android specific jarjar transformer to drop compat annotations
    // for newly repackaged classes. Dropping @UnsupportedAppUsage on repackaged classes
    // avoids adding new hiddenapis after jarjar'ing.
    " -DremoveAndroidCompatAnnotations=true" +
    " -jar ${config.JarjarCmd} process $rulesFile $in $out $total_shards $shard_index && " +
    // Turn a missing output file into a ninja error
    `[ -e ${out} ] || (echo "Missing output file"; exit 1)`,
   CommandDeps:     []string{"${config.JavaCmd}", "${config.JarjarCmd}", "$rulesFile"},
   SandboxDisabled: true,
  },
  "rulesFile", "total_shards", "shard_index")

 packageCheck = pctx.AndroidStaticRule("packageCheck",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    rm, " -f $out && ",
    packageCheckCmd, " $in $packages && ",
    touch, " $out",
   ),
  },
  "packages")

 jetifier = pctx.AndroidStaticRule("jetifier",
  blueprint.RuleParams{
   Command:         "${config.JavaCmd}  ${config.JavaVmFlags} -jar ${config.JetifierJar} -l error -o $out -i $in -t epoch",
   CommandDeps:     []string{"${config.JavaCmd}", "${config.JetifierJar}"},
   SandboxDisabled: true,
  },
 )

 ravenizer = pctx.AndroidStaticRule("ravenizer",
  blueprint.RuleParams{
   Command:         "rm -f $out && ${ravenizer} --in-jar $in --out-jar $out $ravenizerArgs",
   CommandDeps:     []string{"${ravenizer}"},
   SandboxDisabled: true,
  },
  "ravenizerArgs")

 apimapper = pctx.AndroidStaticRule("apimapper",
  blueprint.RuleParams{
   Command:         "${apimapper} --in-jar $in --out-jar $out",
   CommandDeps:     []string{"${apimapper}"},
   SandboxDisabled: true,
  },
 )

 zipalign = pctx.AndroidStaticRule("zipalign",
  blueprint.RuleParams{
   Command: "if ! ${config.ZipAlign} -c -p 4 $in > /dev/null; then " +
    "${config.ZipAlign} -f -p 4 $in $out; " +
    "else " +
    "cp -f $in $out; " +
    "fi",
   CommandDeps:     []string{"${config.ZipAlign}"},
   SandboxDisabled: true,
  },
 )

 convertImplementationJarToHeaderJarRule = pctx.AndroidStaticRule("convertImplementationJarToHeaderJar",
  blueprint.RuleParams{
   Command:         `${config.Zip2ZipCmd} -i ${in} -o ${out} -x 'META-INF/services/**/*'`,
   CommandDeps:     []string{"${config.Zip2ZipCmd}"},
   SandboxDisabled: true,
  })

 writeCombinedProguardFlagsFileRule = pctx.AndroidStaticRule("writeCombinedProguardFlagsFileRule",
  blueprint.RuleParams{
   Command2: blueprint.NewCommand(
    android.Rm, ` -f $out && `,
    `for f in $in; do `,
    android.Echo, ` && `,
    android.Echo, ` "# including $$f" && `,
    android.Cat, ` $$f; `,
    `done > $out`,
   ),
  })

 gatherReleasedFlaggedApisRule = pctx.AndroidStaticRule("gatherReleasedFlaggedApisRule",
  blueprint.RuleParams{
   Command: `${aconfig} dump-cache --dedup --format=protobuf ` +
    `--out ${out} ` +
    `@$out.rsp ` +
    `${filter_args} `,
   CommandDeps:     []string{"${aconfig}"},
   Description:     "aconfig_bool",
   Rspfile:         "$out.rsp",
   RspfileContent:  "${flags_path}",
   SandboxDisabled: true,
  }, "flags_path", "filter_args")

 generateMetalavaFlagConfigRule = pctx.AndroidStaticRule("generateMetalavaFlagConfigRule",
  blueprint.RuleParams{
   Command:         `${aconfig-to-metalava-flags} ${args} ${in} > ${out}`,
   CommandDeps:     []string{"${aconfig-to-metalava-flags}"},
   SandboxDisabled: true,
  }, "args")

 generateApiXMLRule = pctx.AndroidStaticRule("generateApiXMLRule",
  blueprint.RuleParams{
   Command:         `${config.JavaCmd} ${config.JavaVmFlags} -Xmx4g -jar ${config.MetalavaJar} jar-to-jdiff ${in} ${out}`,
   CommandDeps:     []string{"${config.JavaCmd}", "${config.MetalavaJar}"},
   Description:     "Converting API file to XML",
   SandboxDisabled: true,
  })
)

func init() {
 pctx.Import("android/soong/android")
 pctx.Import("android/soong/java/config")

 pctx.HostBinToolVariable("aconfig", "aconfig")
 pctx.HostBinToolVariable("ravenizer", "ravenizer")
 pctx.HostBinToolVariable("apimapper", "apimapper")
 pctx.HostBinToolVariable("aconfig-to-metalava-flags", "aconfig-to-metalava-flags")
}

type javaBuilderFlags struct {
 javacFlags     string
 javacFlagsDeps android.Paths

 // bootClasspath is the list of jars that form the boot classpath (generally the java.* and
 // android.* classes) for tools that still use it.  javac targeting 1.9 or higher uses
 // systemModules and java9Classpath instead.
 bootClasspath classpath

 // classpath is the list of jars that form the classpath for javac and kotlinc rules.  It
 // contains header jars for all static and non-static dependencies.
 classpath classpath

 // directClasspath contains just the direct dependencies (header jars) for strict deps verification.
 directClasspath classpath

 // dexClasspath is the list of jars that form the classpath for d8 and r8 rules.  It contains
 // header jars for all non-static dependencies.  Static dependencies have already been
 // combined into the program jar.
 dexClasspath classpath

 // java9Classpath is the list of jars that will be added to the classpath when targeting
 // 1.9 or higher.  It generally contains the android.* classes, while the java.* classes
 // are provided by systemModules.
 java9Classpath classpath

 processorPath   classpath
 processors      []string
 systemModules   *systemModules
 aidlFlags       string
 strictDepsLevel string
 aidlDeps        android.Paths
 javaVersion     javaVersion

 errorProneExtraJavacFlags  string
 errorProneProcessorPath    classpath
 javaStrictDepsPluginJars   android.Paths
 kotlinStrictDepsPluginJars android.Paths

 kotlincFlags                string
 kotlincPluginFlags          string
 composePluginFlag           string
 composeEmbeddablePluginFlag string
 kotlincClasspath            classpath
 kotlincDeps                 android.Paths
 kotlincFriendPathsArg       string
 kSnapshotFiles              map[string]android.Path

 proto android.ProtoFlags
}

func DefaultJavaBuilderFlags() javaBuilderFlags {
 return javaBuilderFlags{
  javaVersion: JAVA_VERSION_8,
 }
}

func TransformJavaToClassesInc(ctx android.ModuleContext, outputFile android.WritablePath,
 srcFiles, srcJars, headerJars, crossModuleHeaderJars android.Paths, annoSrcJar android.WritablePath, flags javaBuilderFlags, deps android.Paths, genAnnoSrcJars android.Paths) {

 // Compile java sources into .class files
 desc := "javac-inc"
 transformJavaToClassesInc(ctx, outputFile, srcFiles, srcJars, headerJars, crossModuleHeaderJars, annoSrcJar, flags, deps, "javac", desc, genAnnoSrcJars)
}

func TransformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath, shardIdx int,
 srcFiles, srcJars android.Paths, annoSrcJar android.WritablePath, flags javaBuilderFlags, deps android.Paths, genAnnoSrcJars android.Paths) {

 // Compile java sources into .class files
 desc := "javac"
 if shardIdx >= 0 {
  desc += strconv.Itoa(shardIdx)
 }
 transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, annoSrcJar, false, flags, deps, "javac", desc, genAnnoSrcJars)
}
func GenerateJavaAnnotations(ctx android.ModuleContext, outputFile android.WritablePath, shardIdx int,
 srcFiles, srcJars android.Paths, annoSrcJar android.WritablePath, flags javaBuilderFlags, deps android.Paths) {

 // Generate src files from Java Annotations.
 desc := "javac-apt"
 if shardIdx >= 0 {
  desc += strconv.Itoa(shardIdx)
 }

 transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, annoSrcJar, true, flags, deps, "javac-apt", desc, nil)
}

// Emits the rule to generate Xref input file (.kzip file) for the given set of source files and source jars
// to compile with given set of builder flags, etc.
func emitXrefRule(ctx android.ModuleContext, xrefFile android.WritablePath, idx int,
 srcFiles, srcJars android.Paths,
 flags javaBuilderFlags, deps android.Paths) {

 deps = append(deps, srcJars...)
 classpath := flags.classpath

 var bootClasspath string
 if flags.javaVersion.usesJavaModules() {
  var systemModuleDeps android.Paths
  bootClasspath, systemModuleDeps = flags.systemModules.FormJavaSystemModulesPath(ctx.Device())
  deps = append(deps, systemModuleDeps...)
  classpath = append(flags.java9Classpath, classpath...)
 } else {
  deps = append(deps, flags.bootClasspath...)
  if len(flags.bootClasspath) == 0 && ctx.Device() {
   // explicitly specify -bootclasspath "" if the bootclasspath is empty to
   // ensure java does not fall back to the default bootclasspath.
   bootClasspath = `-bootclasspath ""`
  } else {
   bootClasspath = flags.bootClasspath.FormJavaClassPath("-bootclasspath")
  }
 }

 deps = append(deps, classpath...)
 deps = append(deps, flags.processorPath...)
 deps = append(deps, flags.javacFlagsDeps...)

 processor := "-proc:none"
 if len(flags.processors) > 0 {
  processor = "-processor " + strings.Join(flags.processors, ",")
 }

 intermediatesDir := "xref"
 if idx >= 0 {
  intermediatesDir += strconv.Itoa(idx)
 }

 classpathArg := classpath.FormJavaClassPath("-classpath")

 ctx.Build(pctx,
  android.BuildParams{
   Rule:        kytheExtract,
   Description: "Xref Java extractor",
   Output:      xrefFile,
   Inputs:      srcFiles,
   Implicits:   deps,
   Args: map[string]string{
    "annoDir":       android.PathForModuleOut(ctx, intermediatesDir, "anno").String(),
    "bootClasspath": bootClasspath,
    "classpath":     classpathArg,
    "javacFlags":    flags.javacFlags,
    "javaVersion":   flags.javaVersion.String(),
    "outDir":        android.PathForModuleOut(ctx, "javac", "classes.xref").String(),
    "processorpath": flags.processorPath.FormJavaClassPath("-processorpath"),
    "processor":     processor,
    "srcJarDir":     android.PathForModuleOut(ctx, intermediatesDir, "srcjars.xref").String(),
    "srcJars":       strings.Join(srcJars.Strings(), " "),
   },
  })
}

func turbineFlags(ctx android.ModuleContext, flags javaBuilderFlags, dir string, srcJars android.Paths) (string, android.Paths, android.Paths, android.Paths) {
 var implicits android.Paths
 var rbeInputs android.Paths
 var rspFiles android.Paths

 classpath := flags.classpath

 srcJarArgs := strings.Join(srcJars.Strings(), " ")
 implicits = append(implicits, srcJars...)
 const srcJarArgsLimit = 32 * 1024
 if len(srcJarArgs) > srcJarArgsLimit {
  srcJarRspFile := android.PathForModuleOut(ctx, "turbine", "srcjars.rsp")
  android.WriteFileRule(ctx, srcJarRspFile, strings.Join(srcJars.Strings(), "\n"))
  srcJarArgs = "@" + srcJarRspFile.String()
  implicits = append(implicits, srcJarRspFile)
  rspFiles = append(rspFiles, srcJarRspFile)
  rbeInputs = append(rbeInputs, srcJarRspFile)
 } else {
  rbeInputs = append(rbeInputs, srcJars...)
 }

 var bootClasspathFlags string
 if flags.javaVersion.usesJavaModules() {
  var systemModuleDeps android.Paths
  bootClasspathFlags, systemModuleDeps = flags.systemModules.FormTurbineSystemModulesPath(ctx.Device())
  implicits = append(implicits, systemModuleDeps...)
  rbeInputs = append(rbeInputs, systemModuleDeps...)
  classpath = append(flags.java9Classpath, classpath...)
 } else {
  implicits = append(implicits, flags.bootClasspath...)
  rbeInputs = append(rbeInputs, flags.bootClasspath...)
  if len(flags.bootClasspath) == 0 && ctx.Device() {
   // explicitly specify -bootclasspath "" if the bootclasspath is empty to
   // ensure turbine does not fall back to the default bootclasspath.
   bootClasspathFlags = `--bootclasspath ""`
  } else {
   bootClasspathFlags = flags.bootClasspath.FormTurbineClassPath("--bootclasspath ")
  }
 }

 classpathFlags := classpath.FormTurbineClassPath("")
 implicits = append(implicits, classpath...)
 const classpathLimit = 32 * 1024
 if len(classpathFlags) > classpathLimit {
  classpathRspFile := android.PathForModuleOut(ctx, dir, "classpath.rsp")
  android.WriteFileRule(ctx, classpathRspFile, strings.Join(classpath.Strings(), "\n"))
  classpathFlags = "@" + classpathRspFile.String()
  implicits = append(implicits, classpathRspFile)
  rspFiles = append(rspFiles, classpathRspFile)
  rbeInputs = append(rbeInputs, classpathRspFile)
 } else {
  rbeInputs = append(rbeInputs, classpath...)
 }

 implicits = append(implicits, flags.javacFlagsDeps...)

 turbineFlags := "--source_jars " + srcJarArgs + " " + bootClasspathFlags + " --classpath " + classpathFlags

 return turbineFlags, implicits, rbeInputs, rspFiles
}

func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.WritablePath,
 srcFiles, srcJars android.Paths, flags javaBuilderFlags) {

 turbineFlags, implicits, rbeInputs, rspFiles := turbineFlags(ctx, flags, "turbine", srcJars)

 rule := turbine
 args := map[string]string{
  "javacFlags":   flags.javacFlags,
  "javaVersion":  flags.javaVersion.String(),
  "turbineFlags": turbineFlags,
  "outputFlags":  "--output " + outputFile.String() + ".tmp",
  "outputs":      outputFile.String(),
 }
 if ctx.Config().UseREWrapper() && ctx.Config().IsEnvTrue("RBE_TURBINE") {
  rule = turbineRE
  args["rbeInputs"] = strings.Join(rbeInputs.Strings(), ",")
  args["rbeOutputs"] = outputFile.String() + ".tmp"
  args["rspFiles"] = strings.Join(rspFiles.Strings(), ",")
 }
 ctx.Build(pctx, android.BuildParams{
  Rule:        rule,
  Description: "turbine",
  Output:      outputFile,
  Inputs:      srcFiles,
  Implicits:   implicits,
  Args:        args,
 })
}

// TurbineApt produces a rule to run annotation processors using turbine.
func TurbineApt(ctx android.ModuleContext, outputSrcJar, outputResJar android.WritablePath,
 srcFiles, srcJars android.Paths, flags javaBuilderFlags) {

 turbineFlags, implicits, rbeInputs, rspFiles := turbineFlags(ctx, flags, "turbine-apt", srcJars)

 implicits = append(implicits, flags.processorPath...)
 rbeInputs = append(rbeInputs, flags.processorPath...)
 turbineFlags += " " + flags.processorPath.FormTurbineClassPath("--processorpath ")
 turbineFlags += " --processors " + strings.Join(flags.processors, " ")

 outputs := android.WritablePaths{outputSrcJar, outputResJar}
 outputFlags := "--gensrc_output " + outputSrcJar.String() + ".tmp " +
  "--resource_output " + outputResJar.String() + ".tmp"

 rule := turbine
 args := map[string]string{
  "javacFlags":   flags.javacFlags,
  "javaVersion":  flags.javaVersion.String(),
  "turbineFlags": turbineFlags,
  "outputFlags":  outputFlags,
  "outputs":      strings.Join(outputs.Strings(), " "),
 }
 if ctx.Config().UseREWrapper() && ctx.Config().IsEnvTrue("RBE_TURBINE") {
  rule = turbineRE
  args["rbeInputs"] = strings.Join(rbeInputs.Strings(), ",")
  args["rbeOutputs"] = outputSrcJar.String() + ".tmp," + outputResJar.String() + ".tmp"
  args["rspFiles"] = strings.Join(rspFiles.Strings(), ",")
 }
 ctx.Build(pctx, android.BuildParams{
  Rule:            rule,
  Description:     "turbine apt",
  Output:          outputs[0],
  ImplicitOutputs: outputs[1:],
  Inputs:          srcFiles,
  Implicits:       implicits,
  Args:            args,
 })
}

func injectStrictDepsFlags(ctx android.ModuleContext, flags javaBuilderFlags, deps android.Paths, rspFile android.WritablePath) (javaBuilderFlags, android.Paths) {
 // Inject the strict deps plugin into the javac execution
 flags.processorPath = append(flags.processorPath, flags.javaStrictDepsPluginJars...)
 deps = append(deps, flags.javaStrictDepsPluginJars...)

 android.WriteFileRule(ctx, rspFile, strings.Join(flags.directClasspath.Strings(), "\n"))
 deps = append(deps, rspFile)
 flags.javacFlags += " -Xplugin:\"JavaStrictDeps " + rspFile.String() + " " + flags.strictDepsLevel + "\""
 flags.javacFlags += " -J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED"
 flags.javacFlags += " -J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED"
 flags.javacFlags += " -J--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED"
 return flags, deps
}

// Similar to transformJavaToClasses, with additional tweaks to make java
// compilation work incrementally (i.e. work with a smaller subset of src java files
// rather than the full set)
func transformJavaToClassesInc(ctx android.ModuleContext, outputFile android.WritablePath,
 srcFiles, srcJars, shardingHeaderJars, crossModuleHeaderJars android.Paths, annoSrcJar android.WritablePath,
 flags javaBuilderFlags, deps android.Paths, intermediatesDir, desc string, genAnnoSrcJars android.Paths) {

 javacClasspath := flags.classpath

 var bootClasspath string
 if flags.javaVersion.usesJavaModules() {
  var systemModuleDeps android.Paths
  bootClasspath, systemModuleDeps = flags.systemModules.FormJavaSystemModulesPath(ctx.Device())
  deps = append(deps, systemModuleDeps...)
  javacClasspath = append(flags.java9Classpath, javacClasspath...)
 } else {
  deps = append(deps, flags.bootClasspath...)
  if len(flags.bootClasspath) == 0 && ctx.Device() {
   // explicitly specify -bootclasspath "" if the bootclasspath is empty to
   // ensure java does not fall back to the default bootclasspath.
   bootClasspath = `-bootclasspath ""`
  } else {
   bootClasspath = flags.bootClasspath.FormJavaClassPath("-bootclasspath")
  }
 }

 deps = append(deps, flags.processorPath...)
 deps = append(deps, javacClasspath...)

 // Exclude some headers from deps.
 // Headers will become deps for the jar.crossmoduledeps.rsp, which in turn will be a dep
 // for the final compiled jar.
 // These headers must be excluded because, currently, changes in deps causes a full javac
 // recompilation. If changes to deps ever becomes incremental, this removal can be
 // revisisted.
 if crossModuleHeaderJars != nil {
  deps = slices.DeleteFunc(deps, func(dep android.Path) bool {
   return slices.Contains(crossModuleHeaderJars, dep)
  })
 }

 // The file containing dependencies of the current module
 // Any change in them may warrant changes in the incremental compilation
 // source set.
 javacDeps := outputFile.ReplaceExtension(ctx, "jar.deps.rsp")
 android.WriteFileRule(ctx, javacDeps, strings.Join(deps.Strings(), "\n"))
 deps = append(deps, javacDeps)

 // Add localHeader Jars in classpath, they are required for incremental compilation.
 // These are conspicuously not added to javacDeps file, as a change in them
 // does not warrant full re-compilation.
 javacClasspath = append(classpath(slices.Clone(shardingHeaderJars)), javacClasspath...)
 deps = append(deps, shardingHeaderJars...)
 shardingHeaderRsp := outputFile.ReplaceExtension(ctx, "jar.headers.rsp")
 android.WriteFileRule(ctx, shardingHeaderRsp, strings.Join(shardingHeaderJars.Strings(), "\n"))
 deps = append(deps, shardingHeaderRsp)

 crossModuleDepsRsp := outputFile.ReplaceExtension(ctx, "jar.crossmoduledeps.rsp")
 if crossModuleHeaderJars != nil {
  android.WriteFileRule(ctx, crossModuleDepsRsp, strings.Join(crossModuleHeaderJars.Strings(), "\n"))
  deps = append(deps, crossModuleDepsRsp)
 }

 // Doing this now, so that they are not added to javacDeps file
 deps = append(deps, srcJars...)

 classpathArg := javacClasspath.FormJavaClassPath("-classpath")

 // Keep the command line under the MAX_ARG_STRLEN limit by putting the classpath argument into an rsp file
 // if it is too long.
 const classpathLimit = 64 * 1024
 if len(classpathArg) > classpathLimit {
  classpathRspFile := outputFile.ReplaceExtension(ctx, "classpath")
  android.WriteFileRule(ctx, classpathRspFile, classpathArg)
  deps = append(deps, classpathRspFile)
  classpathArg = "@" + classpathRspFile.String()
 }

 processor := "-proc:none"
 if len(flags.processors) > 0 {
  processor = "-processor " + strings.Join(flags.processors, ",")
 }

 srcJarDir := "srcjars"
 outDir := "classes"
 annoDir := "anno"
 srcJarList := android.PathForModuleOut(ctx, intermediatesDir, srcJarDir, "list")
 deps = append(deps, srcJarList)

 // Extract srcJars as a separate action, so that it's not re-executed every time
 // inc-javac is run, if srcJars were themselves not re-generated.
 ctx.Build(pctx, android.BuildParams{
  Rule:        extractSrcJars,
  Description: "javacExtractSrcJars",
  Inputs:      srcJars,
  Output:      srcJarList,
  Args: map[string]string{
   "extractDir": android.PathForModuleOut(ctx, intermediatesDir, srcJarDir).String(),
   "jars":       strings.Join(srcJars.Strings(), " "),
  },
 })

 // Extract annoSrcJars as a separate action, so that it's not re-executed every time
 // inc-javac is run, if annoSrcJars were themselves not re-generated.
 genAnnoSrcJarList := android.PathForModuleOut(ctx, intermediatesDir, annoDir, "list")
 deps = append(deps, genAnnoSrcJarList)
 ctx.Build(pctx, android.BuildParams{
  Rule:        extractSrcJars,
  Description: "javacExtractAnnoSrcJar",
  Inputs:      genAnnoSrcJars,
  Output:      genAnnoSrcJarList,
  Args: map[string]string{
   "extractDir": android.PathForModuleOut(ctx, intermediatesDir, annoDir).String(),
   "jars":       strings.Join(genAnnoSrcJars.Strings(), " "),
  },
 })

 deps = append(deps, flags.javacFlagsDeps...)

 if flags.strictDepsLevel == "warn" || flags.strictDepsLevel == "error" {
  rspFile := outputFile.ReplaceExtension(ctx, "strict_deps.rsp")
  flags, deps = injectStrictDepsFlags(ctx, flags, deps, rspFile)
 }

 rule := javacInc
 ctx.Build(pctx, android.BuildParams{
  Rule:           rule,
  Description:    desc,
  Output:         outputFile,
  ImplicitOutput: annoSrcJar,
  Inputs:         srcFiles,
  Implicits:      append(deps, ctx.Config().UsePartialCompileFile(ctx)),
  Args: map[string]string{
   "javacFlags":        flags.javacFlags,
   "bootClasspath":     bootClasspath,
   "classpath":         classpathArg,
   "processorpath":     flags.processorPath.FormJavaClassPath("-processorpath"),
   "processor":         processor,
   "srcJarList":        srcJarList.String(),
   "genAnnoSrcJarList": genAnnoSrcJarList.String(),
   "outDir":            android.PathForModuleOut(ctx, intermediatesDir, outDir).String(),
   "annoDir":           android.PathForModuleOut(ctx, intermediatesDir, annoDir).String(),
   "annoSrcJar":        annoSrcJar.String(),
   "javaVersion":       flags.javaVersion.String(),
   "javacDeps":         javacDeps.String(),
   "localHeaderJars":   shardingHeaderRsp.String(),
   "crossModuleJars":   crossModuleDepsRsp.String(),
  },
 })

 // The Phony Clean rule allows javac to move from incremental to full, without
 // re-analysis by removing all the outputs of javac, triggering all rules
 // that generate them.
 cleanPhonyPath := android.PathForModuleOut(ctx, "dex", outputFile.String()+"-partialcompileclean").OutputPath
 // Generate the rule for partial compile clean.
 ctx.Build(pctx, android.BuildParams{
  Rule:        javacIncClean,
  Description: "javacIncClean",
  Output:      cleanPhonyPath,
  Args: map[string]string{
   "srcJarDir":  android.PathForModuleOut(ctx, intermediatesDir, srcJarDir).String(),
   "outDir":     android.PathForModuleOut(ctx, intermediatesDir, outDir).String(),
   "annoDir":    android.PathForModuleOut(ctx, intermediatesDir, annoDir).String(),
   "annoSrcJar": annoSrcJar.String(),
   "builtOut":   outputFile.String(),
  },
  PhonyOutput: true,
 })
 ctx.Phony("partialcompileclean", cleanPhonyPath)
}

// transformJavaToClasses takes source files and converts them to a jar containing .class files.
// srcFiles is a list of paths to sources, srcJars is a list of paths to jar files that contain
// sources.  flags contains various command line flags to be passed to the compiler.
//
// This method may be used for different compilers, including javac and Error Prone.  The rule
// argument specifies which command line to use and desc sets the description of the rule that will
// be printed at build time.  The stem argument provides the file name of the output jar, and
// suffix will be appended to various intermediate files and directories to avoid collisions when
// this function is called twice in the same module directory.
//
// This method can also be used to only process Annotations, without completely
// compiling java sources.
func transformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath,
 shardIdx int, srcFiles, srcJars android.Paths, annoSrcJar android.WritablePath, onlyGenerateAnnotations bool,
 flags javaBuilderFlags, deps android.Paths,
 intermediatesDir, desc string, genAnnoSrcJars android.Paths) {

 deps = append(deps, srcJars...)

 javacClasspath := flags.classpath

 var bootClasspath string
 if flags.javaVersion.usesJavaModules() {
  var systemModuleDeps android.Paths
  bootClasspath, systemModuleDeps = flags.systemModules.FormJavaSystemModulesPath(ctx.Device())
  deps = append(deps, systemModuleDeps...)
  javacClasspath = append(flags.java9Classpath, javacClasspath...)
 } else {
  deps = append(deps, flags.bootClasspath...)
  if len(flags.bootClasspath) == 0 && ctx.Device() {
   // explicitly specify -bootclasspath "" if the bootclasspath is empty to
   // ensure java does not fall back to the default bootclasspath.
   bootClasspath = `-bootclasspath ""`
  } else {
   bootClasspath = flags.bootClasspath.FormJavaClassPath("-bootclasspath")
  }
 }

 classpathArg := javacClasspath.FormJavaClassPath("-classpath")

 // Keep the command line under the MAX_ARG_STRLEN limit by putting the classpath argument into an rsp file
 // if it is too long.
 const classpathLimit = 64 * 1024
 if len(classpathArg) > classpathLimit {
  classpathRspFile := outputFile.AddExtension(ctx, "classpath")
  android.WriteFileRule(ctx, classpathRspFile, classpathArg)
  deps = append(deps, classpathRspFile)
  classpathArg = "@" + classpathRspFile.String()
 }

 deps = append(deps, javacClasspath...)
 deps = append(deps, flags.processorPath...)
 deps = append(deps, genAnnoSrcJars...)
 deps = append(deps, flags.javacFlagsDeps...)

 if flags.strictDepsLevel == "warn" || flags.strictDepsLevel == "error" {
  var rspFile android.WritablePath
  if shardIdx >= 0 {
   rspFile = android.PathForModuleOut(ctx, intermediatesDir, "shard"+strconv.Itoa(shardIdx), "strict_deps.rsp")
  } else {
   rspFile = android.PathForModuleOut(ctx, intermediatesDir, "strict_deps.rsp")
  }
  flags, deps = injectStrictDepsFlags(ctx, flags, deps, rspFile)
 }

 processor := "-proc:none"
 if len(flags.processors) > 0 {
  if onlyGenerateAnnotations {
   processor = "-proc:only -processor " + strings.Join(flags.processors, ",")
  } else {
   processor = "-processor " + strings.Join(flags.processors, ",")
  }
 }

 srcJarDir := "srcjars"
 outDir := "classes"
 annoDir := "anno"
 if shardIdx >= 0 {
  shardDir := "shard" + strconv.Itoa(shardIdx)
  srcJarDir = filepath.Join(shardDir, srcJarDir)
  outDir = filepath.Join(shardDir, outDir)
  annoDir = filepath.Join(shardDir, annoDir)
 }
 rule := javac
 if ctx.Config().UseREWrapper() && ctx.Config().IsEnvTrue("RBE_JAVAC") {
  rule = javacRE
 }
 ctx.Build(pctx, android.BuildParams{
  Rule:           rule,
  Description:    desc,
  Output:         outputFile,
  ImplicitOutput: annoSrcJar,
  Inputs:         srcFiles,
  Implicits:      deps,
  Args: map[string]string{
   "javacFlags":     flags.javacFlags,
   "bootClasspath":  bootClasspath,
   "classpath":      classpathArg,
   "processorpath":  flags.processorPath.FormJavaClassPath("-processorpath"),
   "processor":      processor,
   "srcJars":        strings.Join(srcJars.Strings(), " "),
   "srcJarDir":      android.PathForModuleOut(ctx, intermediatesDir, srcJarDir).String(),
   "outDir":         android.PathForModuleOut(ctx, intermediatesDir, outDir).String(),
   "annoDir":        android.PathForModuleOut(ctx, intermediatesDir, annoDir).String(),
   "annoSrcJar":     annoSrcJar.String(),
   "genAnnoSrcJars": strings.Join(genAnnoSrcJars.Strings(), " "),
   "javaVersion":    flags.javaVersion.String(),
  },
 })
}

func TransformResourcesToJar(ctx android.ModuleContext, outputFile android.WritablePath,
 jarArgs []string, deps android.Paths) {

 rule := jar
 args := map[string]string{
  "jarArgs": strings.Join(proptools.NinjaAndShellEscapeList(jarArgs), " "),
 }
 if ctx.Config().UseREWrapper() && ctx.Config().IsEnvTrue("RBE_JAR") {
  rule = jarRE
  // Create an RSP file listing all the inputs for RBE.
  rbeInputs := android.PathForModuleOut(ctx, "rbe_inputs.rsp")
  android.WriteFileRule(ctx, rbeInputs, strings.Join(deps.Strings(), " "))
  args["rspFiles"] = rbeInputs.String()
  deps = append(deps, rbeInputs)
 }
 ctx.Build(pctx, android.BuildParams{
  Rule:        rule,
  Description: "jar",
  Output:      outputFile,
  Implicits:   deps,
  Args:        args,
 })
}

func TransformJarsToJar(ctx android.ModuleContext, outputFile android.WritablePath, desc string,
 jars android.Paths, manifest android.OptionalPath, stripDirEntries bool, filesToStrip []string,
 dirsToStrip []string) {

 var deps android.Paths

 var jarArgs []string
 if manifest.Valid() {
  jarArgs = append(jarArgs, "-m ", manifest.String())
  deps = append(deps, manifest.Path())
 }

 for _, dir := range dirsToStrip {
  jarArgs = append(jarArgs, "-stripDir ", dir)
 }

 for _, file := range filesToStrip {
  jarArgs = append(jarArgs, "-stripFile ", file)
 }

 // Remove any module-info.class files that may have come from prebuilt jars, they cause problems
 // for downstream tools like desugar.
 jarArgs = append(jarArgs, "-stripFile module-info.class")
 jarArgs = append(jarArgs, "-stripFile META-INF/versions/*/module-info.class")

 if stripDirEntries {
  jarArgs = append(jarArgs, "-D")
 }

 rule := combineJar
 // Keep the command line under the MAX_ARG_STRLEN limit by putting the list of jars into an rsp file
 // if it is too long.
 const jarsLengthLimit = 64 * 1024
 jarsLength := 0
 for i, jar := range jars {
  if i != 0 {
   jarsLength += 1
  }
  jarsLength += len(jar.String())
 }
 if jarsLength > jarsLengthLimit {
  rule = combineJarRsp
 }

 ctx.Build(pctx, android.BuildParams{
  Rule:        rule,
  Description: desc,
  Output:      outputFile,
  Inputs:      jars,
  Implicits:   deps,
  Args: map[string]string{
   "jarArgs": strings.Join(jarArgs, " "),
  },
 })
}

func TransformJarToR8Rules(ctx android.ModuleContext, outputFile android.WritablePath,
 jar android.Path) {

 ctx.Build(pctx, android.BuildParams{
  Rule:   extractR8Rules,
  Output: outputFile,
  Input:  jar,
 })
}

func convertImplementationJarToHeaderJar(ctx android.ModuleContext, implementationJarFile android.Path,
 headerJarFile android.WritablePath) {
 ctx.Build(pctx, android.BuildParams{
  Rule:   convertImplementationJarToHeaderJarRule,
  Input:  implementationJarFile,
  Output: headerJarFile,
 })
}

func TransformJarJar(ctx android.ModuleContext, outputFile android.WritablePath,
 classesJar android.Path, rulesFile android.Path) {
 TransformJarJarWithShards(ctx, outputFile, classesJar, rulesFile, 1)
}

func TransformJarJarWithShards(ctx android.ModuleContext, outputFile android.WritablePath,
 classesJar android.Path, rulesFile android.Path, totalShards int) {

 // If the total number of shards is 1, just run jarjar as-is, with `total_shards` = 1
 // and `shard_index` == 0, which effectively disables sharding
 if totalShards == 1 {
  ctx.Build(pctx, android.BuildParams{
   Rule:        jarjar,
   Description: "jarjar",
   Output:      outputFile,
   Input:       classesJar,
   Implicit:    rulesFile,
   Args: map[string]string{
    "rulesFile":    rulesFile.String(),
    "total_shards": "1",
    "shard_index":  "0",
   },
  })
  return
 }

 // Otherwise, run multiple jarjar instances and use merge_zips to combine the output.
 tempJars := make([]android.Path, 0)
 totalStr := strconv.Itoa(totalShards)
 for i := 0; i < totalShards; i++ {
  iStr := strconv.Itoa(i)
  tempOut := outputFile.ReplaceExtension(ctx, "-"+iStr+".jar")
  ctx.Build(pctx, android.BuildParams{
   Rule:        jarjar,
   Description: "jarjar (" + iStr + "/" + totalStr + ")",
   Output:      tempOut,
   Input:       classesJar,
   Implicit:    rulesFile,
   Args: map[string]string{
    "rulesFile":    rulesFile.String(),
    "total_shards": totalStr,
    "shard_index":  iStr,
   },
  })
  tempJars = append(tempJars, tempOut)
 }

 ctx.Build(pctx, android.BuildParams{
  Rule:        combineJar,
  Description: "merge jarjar shards",
  Output:      outputFile,
  Inputs:      tempJars,
 })

}

func CheckJarPackages(ctx android.ModuleContext, outputFile android.WritablePath,
 classesJar android.Path, permittedPackages []string) {
 ctx.Build(pctx, android.BuildParams{
  Rule:        packageCheck,
  Description: "packageCheck",
  Output:      outputFile,
  Input:       classesJar,
  Args: map[string]string{
   "packages": strings.Join(permittedPackages, " "),
  },
 })
}

func TransformJetifier(ctx android.ModuleContext, outputFile android.WritablePath,
 inputFile android.Path) {
 ctx.Build(pctx, android.BuildParams{
  Rule:        jetifier,
  Description: "jetifier",
  Output:      outputFile,
  Input:       inputFile,
 })
}

func TransformRavenizer(ctx android.ModuleContext, outputFile android.WritablePath,
 inputFile android.Path, ravenizerArgs []string) {
 ctx.Build(pctx, android.BuildParams{
  Rule:        ravenizer,
  Description: "ravenizer",
  Output:      outputFile,
  Input:       inputFile,
  Args: map[string]string{
   "ravenizerArgs": strings.Join(ravenizerArgs, " "),
  },
 })
}

func GenerateMainClassManifest(ctx android.ModuleContext, outputFile android.WritablePath, mainClass string) {
 android.WriteFileRule(ctx, outputFile, "Main-Class: "+mainClass+"\n")
}

func TransformZipAlign(ctx android.ModuleContext, outputFile android.WritablePath, inputFile android.Path, validations android.Paths) {
 ctx.Build(pctx, android.BuildParams{
  Rule:        zipalign,
  Description: "align",
  Input:       inputFile,
  Output:      outputFile,
  Validations: validations,
 })
}

func writeCombinedProguardFlagsFile(ctx android.ModuleContext, outputFile android.WritablePath, files android.Paths) {
 ctx.Build(pctx, android.BuildParams{
  Rule:        writeCombinedProguardFlagsFileRule,
  Description: "write combined proguard flags file",
  Inputs:      files,
  Output:      outputFile,
 })
}

type classpath android.Paths

func (x *classpath) formJoinedClassPath(optName string, sep string) string {
 if optName != "" && !strings.HasSuffix(optName, "=") && !strings.HasSuffix(optName, " ") {
  optName += " "
 }
 if len(*x) > 0 {
  return optName + strings.Join(x.Strings(), sep)
 } else {
  return ""
 }
}
func (x *classpath) FormJavaClassPath(optName string) string {
 return x.formJoinedClassPath(optName, ":")
}

func (x *classpath) FormTurbineClassPath(optName string) string {
 return x.formJoinedClassPath(optName, " ")
}

// FormRepeatedClassPath returns a list of arguments with the given optName prefixed to each element of the classpath.
func (x *classpath) FormRepeatedClassPath(optName string) []string {
 if x == nil || *x == nil {
  return nil
 }
 flags := make([]string, len(*x))
 for i, v := range *x {
  flags[i] = optName + v.String()
 }

 return flags
}

func (x *classpath) FirstUniquePaths() classpath {
 return classpath(android.FirstUniquePaths(x.Paths()))
}

// Convert a classpath to an android.Paths
func (x *classpath) Paths() android.Paths {
 return append(android.Paths(nil), (*x)...)
}

func (x *classpath) Strings() []string {
 if x == nil {
  return nil
 }
 ret := make([]string, len(*x))
 for i, path := range *x {
  ret[i] = path.String()
 }
 return ret
}

type systemModules struct {
 dir  android.Path
 deps android.Paths
}

// Returns a --system argument in the form javac expects with -source 1.9 and the list of files to
// depend on.  If forceEmpty is true, returns --system=none if the list is empty to ensure javac
// does not fall back to the default system modules.
func (x *systemModules) FormJavaSystemModulesPath(forceEmpty bool) (string, android.Paths) {
 if x != nil {
  return "--system=" + x.dir.String(), x.deps
 } else if forceEmpty {
  return "--system=none", nil
 } else {
  return "", nil
 }
}

// Returns a --system argument in the form turbine expects with -source 1.9 and the list of files to
// depend on.  If forceEmpty is true, returns --bootclasspath "" if the list is empty to ensure turbine
// does not fall back to the default bootclasspath.
func (x *systemModules) FormTurbineSystemModulesPath(forceEmpty bool) (string, android.Paths) {
 if x != nil {
  return "--system " + x.dir.String(), x.deps
 } else if forceEmpty {
  return `--bootclasspath ""`, nil
 } else {
  return "--system ${config.JavaHome}", nil
 }
}