Merge "Run ErrorProne in OpenJDK9"

android/config.go

@@ -322,10 +322,8 @@ func NewConfig(srcDir, buildDir string) (Config, error) {
 func (c *config) fromEnv() error {
 	switch c.Getenv("EXPERIMENTAL_USE_OPENJDK9") {
 	case "":
-		if c.Getenv("RUN_ERROR_PRONE") != "true" {
+		// Use OpenJDK9, but target 1.8
-			// Use OpenJDK9, but target 1.8
+		c.useOpenJDK9 = true
-			c.useOpenJDK9 = true
-		}
 	case "false":
 		// Use OpenJDK8
 	case "1.8":
@@ -631,6 +629,10 @@ func (c *config) UseGoma() bool {
 	return Bool(c.productVariables.UseGoma)
 }
 
+func (c *config) RunErrorProne() bool {
+	return c.IsEnvTrue("RUN_ERROR_PRONE")
+}
+
 // Returns true if OpenJDK9 prebuilts are being used
 func (c *config) UseOpenJDK9() bool {
 	return c.useOpenJDK9

java/builder.go

@@ -26,7 +26,6 @@ import (
 	"github.com/google/blueprint"
 
 	"android/soong/android"
-	"android/soong/java/config"
 )
 
 var (
@@ -80,29 +79,6 @@ var (
 		},
 		"kotlincFlags", "classpath", "srcJars", "srcJarDir", "outDir", "kotlinJvmTarget")
 
-	errorprone = pctx.AndroidStaticRule("errorprone",
-		blueprint.RuleParams{
-			Command: `rm -rf "$outDir" "$annoDir" "$srcJarDir" && mkdir -p "$outDir" "$annoDir" "$srcJarDir" && ` +
-				`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
-				`${config.SoongJavacWrapper} ${config.ErrorProneCmd} ` +
-				`$processorpath $javacFlags $bootClasspath $classpath ` +
-				`-source $javaVersion -target $javaVersion ` +
-				`-d $outDir -s $annoDir @$out.rsp @$srcJarDir/list && ` +
-				`${config.SoongZipCmd} -jar -o $out -C $outDir -D $outDir`,
-			CommandDeps: []string{
-				"${config.JavaCmd}",
-				"${config.ErrorProneJavacJar}",
-				"${config.ErrorProneJar}",
-				"${config.SoongZipCmd}",
-				"${config.ZipSyncCmd}",
-			},
-			CommandOrderOnly: []string{"${config.SoongJavacWrapper}"},
-			Rspfile:          "$out.rsp",
-			RspfileContent:   "$in",
-		},
-		"javacFlags", "bootClasspath", "classpath", "processorpath", "srcJars", "srcJarDir",
-		"outDir", "annoDir", "javaVersion")
-
 	turbine = pctx.AndroidStaticRule("turbine",
 		blueprint.RuleParams{
 			Command: `rm -rf "$outDir" && mkdir -p "$outDir" && ` +
@@ -161,6 +137,7 @@ type javaBuilderFlags struct {
 	javaVersion   string
 
 	errorProneExtraJavacFlags string
+	errorProneProcessorPath   classpath
 
 	kotlincFlags     string
 	kotlincClasspath classpath
@@ -208,26 +185,24 @@ func TransformJavaToClasses(ctx android.ModuleContext, outputFile android.Writab
 		desc += strconv.Itoa(shardIdx)
 	}
 
-	transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, flags, deps, "javac", desc, javac)
+	transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, flags, deps, "javac", desc)
 }
 
 func RunErrorProne(ctx android.ModuleContext, outputFile android.WritablePath,
 	srcFiles, srcJars android.Paths, flags javaBuilderFlags) {
 
-	if config.ErrorProneJar == "" {
+	flags.processorPath = append(flags.errorProneProcessorPath, flags.processorPath...)
-		ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
-	}
 
 	if len(flags.errorProneExtraJavacFlags) > 0 {
 		if len(flags.javacFlags) > 0 {
-			flags.javacFlags = flags.errorProneExtraJavacFlags + " " + flags.javacFlags
+			flags.javacFlags += " " + flags.errorProneExtraJavacFlags
 		} else {
 			flags.javacFlags = flags.errorProneExtraJavacFlags
 		}
 	}
 
 	transformJavaToClasses(ctx, outputFile, -1, srcFiles, srcJars, flags, nil,
-		"errorprone", "errorprone", errorprone)
+		"errorprone", "errorprone")
 }
 
 func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.WritablePath,
@@ -276,7 +251,7 @@ func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.
 func transformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath,
 	shardIdx int, srcFiles, srcJars android.Paths,
 	flags javaBuilderFlags, deps android.Paths,
-	intermediatesDir, desc string, rule blueprint.Rule) {
+	intermediatesDir, desc string) {
 
 	deps = append(deps, srcJars...)
 
@@ -308,7 +283,7 @@ func transformJavaToClasses(ctx android.ModuleContext, outputFile android.Writab
 		annoDir = filepath.Join(shardDir, annoDir)
 	}
 	ctx.Build(pctx, android.BuildParams{
-		Rule:        rule,
+		Rule:        javac,
 		Description: desc,
 		Output:      outputFile,
 		Inputs:      srcFiles,

java/config/error_prone.go

@@ -14,39 +14,40 @@
 
 package config
 
-import "android/soong/android"
+import (
+	"strings"
+
+	"android/soong/android"
+)
 
 var (
 	// These will be filled out by external/error_prone/soong/error_prone.go if it is available
-	ErrorProneJavacJar              string
+	ErrorProneClasspath             []string
-	ErrorProneJar                   string
+	ErrorProneChecksError           []string
-	ErrorProneClasspath             string
+	ErrorProneChecksWarning         []string
-	ErrorProneChecksError           string
+	ErrorProneChecksDefaultDisabled []string
-	ErrorProneChecksWarning         string
+	ErrorProneChecksOff             []string
-	ErrorProneChecksDefaultDisabled string
+	ErrorProneFlags                 []string
-	ErrorProneFlags                 string
 )
 
 // Wrapper that grabs value of val late so it can be initialized by a later module's init function
-func errorProneVar(name string, val *string) {
+func errorProneVar(name string, val *[]string, sep string) {
 	pctx.VariableFunc(name, func(android.PackageVarContext) string {
-		return *val
+		return strings.Join(*val, sep)
 	})
 }
 
 func init() {
-	errorProneVar("ErrorProneJar", &ErrorProneJar)
+	errorProneVar("ErrorProneClasspath", &ErrorProneClasspath, ":")
-	errorProneVar("ErrorProneJavacJar", &ErrorProneJavacJar)
+	errorProneVar("ErrorProneChecksError", &ErrorProneChecksError, " ")
-	errorProneVar("ErrorProneClasspath", &ErrorProneClasspath)
+	errorProneVar("ErrorProneChecksWarning", &ErrorProneChecksWarning, " ")
-	errorProneVar("ErrorProneChecksError", &ErrorProneChecksError)
+	errorProneVar("ErrorProneChecksDefaultDisabled", &ErrorProneChecksDefaultDisabled, " ")
-	errorProneVar("ErrorProneChecksWarning", &ErrorProneChecksWarning)
+	errorProneVar("ErrorProneChecksOff", &ErrorProneChecksOff, " ")
-	errorProneVar("ErrorProneChecksDefaultDisabled", &ErrorProneChecksDefaultDisabled)
+	errorProneVar("ErrorProneFlags", &ErrorProneFlags, " ")
-	errorProneVar("ErrorProneFlags", &ErrorProneFlags)
+	pctx.StaticVariable("ErrorProneChecks", strings.Join([]string{
-
+		"${ErrorProneChecksOff}",
-	pctx.StaticVariable("ErrorProneCmd",
+		"${ErrorProneChecksError}",
-		"${JavaCmd} -Xmx${JavacHeapSize} -Xbootclasspath/p:${ErrorProneJavacJar} "+
+		"${ErrorProneChecksWarning}",
-			"-cp ${ErrorProneJar}:${ErrorProneClasspath} "+
+		"${ErrorProneChecksDefaultDisabled}",
-			"${ErrorProneFlags} ${CommonJdkFlags} "+
+	}, " "))
-			"${ErrorProneChecksError} ${ErrorProneChecksWarning} ${ErrorProneChecksDefaultDisabled}")
-
 }

java/config/makevars.go

@@ -52,14 +52,15 @@ func makeVarsProvider(ctx android.MakeVarsContext) {
 
 	ctx.Strict("TURBINE", "${TurbineJar}")
 
-	if ctx.Config().IsEnvTrue("RUN_ERROR_PRONE") {
+	if ctx.Config().RunErrorProne() {
-		ctx.Strict("TARGET_JAVAC", "${ErrorProneCmd}")
+		ctx.Strict("ERROR_PRONE_JARS", strings.Join(ErrorProneClasspath, " "))
-		ctx.Strict("HOST_JAVAC", "${ErrorProneCmd}")
+		ctx.Strict("ERROR_PRONE_FLAGS", "${ErrorProneFlags}")
-	} else {
+		ctx.Strict("ERROR_PRONE_CHECKS", "${ErrorProneChecks}")
-		ctx.Strict("TARGET_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
-		ctx.Strict("HOST_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
 	}
 
+	ctx.Strict("TARGET_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
+	ctx.Strict("HOST_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
+
 	if ctx.Config().UseOpenJDK9() {
 		ctx.Strict("JLINK", "${JlinkCmd}")
 		ctx.Strict("JMOD", "${JmodCmd}")

java/java.go

@@ -843,8 +843,20 @@ func (j *Module) collectBuilderFlags(ctx android.ModuleContext, deps deps) javaB
 		flags.javacFlags = "$javacFlags"
 	}
 
-	if len(j.properties.Errorprone.Javacflags) > 0 {
+	if ctx.Config().RunErrorProne() {
-		flags.errorProneExtraJavacFlags = strings.Join(j.properties.Errorprone.Javacflags, " ")
+		if config.ErrorProneClasspath == nil {
+			ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
+		}
+
+		errorProneFlags := []string{
+			"-Xplugin:ErrorProne",
+			"${config.ErrorProneChecks}",
+		}
+		errorProneFlags = append(errorProneFlags, j.properties.Errorprone.Javacflags...)
+
+		flags.errorProneExtraJavacFlags = "${config.ErrorProneFlags} " +
+			"'" + strings.Join(errorProneFlags, " ") + "'"
+		flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
 	}
 
 	// javaVersion flag.
@@ -994,7 +1006,7 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path
 	}
 	if len(uniqueSrcFiles) > 0 || len(srcJars) > 0 {
 		var extraJarDeps android.Paths
-		if ctx.Config().IsEnvTrue("RUN_ERROR_PRONE") {
+		if ctx.Config().RunErrorProne() {
 			// If error-prone is enabled, add an additional rule to compile the java files into
 			// a separate set of classes (so that they don't overwrite the normal ones and require
 			// a rebuild when error-prone is turned off).

ui/build/config.go

@@ -165,15 +165,7 @@ func NewConfig(ctx Context, args ...string) Config {
 			return override
 		}
 		v, ok := ret.environ.Get("EXPERIMENTAL_USE_OPENJDK9")
-		if !ok {
+		if !ok || v != "false" {
-			v2, ok2 := ret.environ.Get("RUN_ERROR_PRONE")
-			if ok2 && (v2 == "true") {
-				v = "false"
-			} else {
-				v = "1.8"
-			}
-		}
-		if v != "false" {
 			return java9Home
 		}
 		return java8Home