1// Copyright 2019 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package java 16 17import ( 18 "bytes" 19 "encoding/base64" 20 "encoding/binary" 21 "path/filepath" 22 "strings" 23 24 "android/soong/android" 25 26 "github.com/google/blueprint" 27) 28 29var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports{Goma: true}, 30 blueprint.RuleParams{ 31 Command: `rm -rf "$classesDir" "$headerClassesDir" "$srcJarDir" "$kotlinBuildFile" "$emptyDir" && ` + 32 `mkdir -p "$classesDir" "$headerClassesDir" "$srcJarDir" "$emptyDir" && ` + 33 `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" -f "*.kt" $srcJars && ` + 34 `${config.GenKotlinBuildFileCmd} --classpath "$classpath" --name "$name"` + 35 ` --out_dir "$classesDir" --srcs "$out.rsp" --srcs "$srcJarDir/list"` + 36 ` $commonSrcFilesArg --out "$kotlinBuildFile" && ` + 37 `${config.KotlincCmd} ${config.KotlincGlobalFlags} ` + 38 ` ${config.KotlincSuppressJDK9Warnings} ${config.JavacHeapFlags} ` + 39 ` $kotlincFlags -jvm-target $kotlinJvmTarget -Xbuild-file=$kotlinBuildFile ` + 40 ` -kotlin-home $emptyDir ` + 41 ` -Xplugin=${config.KotlinAbiGenPluginJar} ` + 42 ` -P plugin:org.jetbrains.kotlin.jvm.abi:outputDir=$headerClassesDir && ` + 43 `${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir -write_if_changed && ` + 44 `${config.SoongZipCmd} -jar -o $headerJar -C $headerClassesDir -D $headerClassesDir -write_if_changed && ` + 45 `rm -rf "$srcJarDir" "$classesDir" "$headerClassesDir"`, 46 CommandDeps: []string{ 47 "${config.KotlincCmd}", 48 "${config.KotlinCompilerJar}", 49 "${config.KotlinPreloaderJar}", 50 "${config.KotlinReflectJar}", 51 "${config.KotlinScriptRuntimeJar}", 52 "${config.KotlinStdlibJar}", 53 "${config.KotlinTrove4jJar}", 54 "${config.KotlinAnnotationJar}", 55 "${config.KotlinAbiGenPluginJar}", 56 "${config.GenKotlinBuildFileCmd}", 57 "${config.SoongZipCmd}", 58 "${config.ZipSyncCmd}", 59 }, 60 Rspfile: "$out.rsp", 61 RspfileContent: `$in`, 62 Restat: true, 63 }, 64 "kotlincFlags", "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "classesDir", 65 "headerClassesDir", "headerJar", "kotlinJvmTarget", "kotlinBuildFile", "emptyDir", "name") 66 67var kotlinKytheExtract = pctx.AndroidStaticRule("kotlinKythe", 68 blueprint.RuleParams{ 69 Command: `rm -rf "$srcJarDir" && mkdir -p "$srcJarDir" && ` + 70 `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" -f "*.kt" $srcJars && ` + 71 `${config.KotlinKytheExtractor} -corpus ${kytheCorpus} --srcs @$out.rsp --srcs @"$srcJarDir/list" $commonSrcFilesList --cp @$classpath -o $out --kotlin_out $outJar ` + 72 // wrap the additional kotlin args. 73 // Skip Xbuild file, pass the cp explicitly. 74 // Skip header jars, those should not have an effect on kythe results. 75 ` --args '${config.KotlincGlobalFlags} ` + 76 ` ${config.KotlincSuppressJDK9Warnings} ${config.JavacHeapFlags} ` + 77 ` $kotlincFlags -jvm-target $kotlinJvmTarget ` + 78 `${config.KotlincKytheGlobalFlags}'`, 79 CommandDeps: []string{ 80 "${config.KotlinKytheExtractor}", 81 "${config.ZipSyncCmd}", 82 }, 83 Rspfile: "$out.rsp", 84 RspfileContent: "$in", 85 }, 86 "classpath", "kotlincFlags", "commonSrcFilesList", "kotlinJvmTarget", "outJar", "srcJars", "srcJarDir", 87) 88 89func kotlinCommonSrcsList(ctx android.ModuleContext, commonSrcFiles android.Paths) android.OptionalPath { 90 if len(commonSrcFiles) > 0 { 91 // The list of common_srcs may be too long to put on the command line, but 92 // we can't use the rsp file because it is already being used for srcs. 93 // Insert a second rule to write out the list of resources to a file. 94 commonSrcsList := android.PathForModuleOut(ctx, "kotlinc_common_srcs.list") 95 rule := android.NewRuleBuilder(pctx, ctx) 96 rule.Command().Text("cp"). 97 FlagWithRspFileInputList("", commonSrcsList.ReplaceExtension(ctx, "rsp"), commonSrcFiles). 98 Output(commonSrcsList) 99 rule.Build("kotlin_common_srcs_list", "kotlin common_srcs list") 100 return android.OptionalPathForPath(commonSrcsList) 101 } 102 return android.OptionalPath{} 103} 104 105// kotlinCompile takes .java and .kt sources and srcJars, and compiles the .kt sources into a classes jar in outputFile. 106func (j *Module) kotlinCompile(ctx android.ModuleContext, outputFile, headerOutputFile android.WritablePath, 107 srcFiles, commonSrcFiles, srcJars android.Paths, 108 flags javaBuilderFlags) { 109 110 var deps android.Paths 111 deps = append(deps, flags.kotlincClasspath...) 112 deps = append(deps, flags.kotlincDeps...) 113 deps = append(deps, srcJars...) 114 deps = append(deps, commonSrcFiles...) 115 116 kotlinName := filepath.Join(ctx.ModuleDir(), ctx.ModuleSubDir(), ctx.ModuleName()) 117 kotlinName = strings.ReplaceAll(kotlinName, "/", "__") 118 119 commonSrcsList := kotlinCommonSrcsList(ctx, commonSrcFiles) 120 commonSrcFilesArg := "" 121 if commonSrcsList.Valid() { 122 deps = append(deps, commonSrcsList.Path()) 123 commonSrcFilesArg = "--common_srcs " + commonSrcsList.String() 124 } 125 126 classpathRspFile := android.PathForModuleOut(ctx, "kotlinc", "classpath.rsp") 127 android.WriteFileRule(ctx, classpathRspFile, strings.Join(flags.kotlincClasspath.Strings(), " ")) 128 deps = append(deps, classpathRspFile) 129 130 ctx.Build(pctx, android.BuildParams{ 131 Rule: kotlinc, 132 Description: "kotlinc", 133 Output: outputFile, 134 ImplicitOutput: headerOutputFile, 135 Inputs: srcFiles, 136 Implicits: deps, 137 Args: map[string]string{ 138 "classpath": classpathRspFile.String(), 139 "kotlincFlags": flags.kotlincFlags, 140 "commonSrcFilesArg": commonSrcFilesArg, 141 "srcJars": strings.Join(srcJars.Strings(), " "), 142 "classesDir": android.PathForModuleOut(ctx, "kotlinc", "classes").String(), 143 "headerClassesDir": android.PathForModuleOut(ctx, "kotlinc", "header_classes").String(), 144 "headerJar": headerOutputFile.String(), 145 "srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars").String(), 146 "kotlinBuildFile": android.PathForModuleOut(ctx, "kotlinc-build.xml").String(), 147 "emptyDir": android.PathForModuleOut(ctx, "kotlinc", "empty").String(), 148 "kotlinJvmTarget": flags.javaVersion.StringForKotlinc(), 149 "name": kotlinName, 150 }, 151 }) 152 153 // Emit kythe xref rule 154 if (ctx.Config().EmitXrefRules()) && ctx.Module() == ctx.PrimaryModule() { 155 extractionFile := outputFile.ReplaceExtension(ctx, "kzip") 156 args := map[string]string{ 157 "classpath": classpathRspFile.String(), 158 "kotlincFlags": flags.kotlincFlags, 159 "kotlinJvmTarget": flags.javaVersion.StringForKotlinc(), 160 "outJar": outputFile.String(), 161 "srcJars": strings.Join(srcJars.Strings(), " "), 162 "srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars.xref").String(), 163 } 164 if commonSrcsList.Valid() { 165 args["commonSrcFilesList"] = "--common_srcs @" + commonSrcsList.String() 166 } 167 ctx.Build(pctx, android.BuildParams{ 168 Rule: kotlinKytheExtract, 169 Description: "kotlinKythe", 170 Output: extractionFile, 171 Inputs: srcFiles, 172 Implicits: deps, 173 Args: args, 174 }) 175 j.kytheKotlinFiles = append(j.kytheKotlinFiles, extractionFile) 176 } 177} 178 179var kaptStubs = pctx.AndroidRemoteStaticRule("kaptStubs", android.RemoteRuleSupports{Goma: true}, 180 blueprint.RuleParams{ 181 Command: `rm -rf "$srcJarDir" "$kotlinBuildFile" "$kaptDir" && ` + 182 `mkdir -p "$srcJarDir" "$kaptDir/sources" "$kaptDir/classes" && ` + 183 `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` + 184 `${config.GenKotlinBuildFileCmd} --classpath "$classpath" --name "$name"` + 185 ` --srcs "$out.rsp" --srcs "$srcJarDir/list"` + 186 ` $commonSrcFilesArg --out "$kotlinBuildFile" && ` + 187 `${config.KotlincCmd} ${config.KotlincGlobalFlags} ` + 188 `${config.KaptSuppressJDK9Warnings} ${config.KotlincSuppressJDK9Warnings} ` + 189 `${config.JavacHeapFlags} $kotlincFlags -Xplugin=${config.KotlinKaptJar} ` + 190 `-P plugin:org.jetbrains.kotlin.kapt3:sources=$kaptDir/sources ` + 191 `-P plugin:org.jetbrains.kotlin.kapt3:classes=$kaptDir/classes ` + 192 `-P plugin:org.jetbrains.kotlin.kapt3:stubs=$kaptDir/stubs ` + 193 `-P plugin:org.jetbrains.kotlin.kapt3:correctErrorTypes=true ` + 194 `-P plugin:org.jetbrains.kotlin.kapt3:aptMode=stubs ` + 195 `-P plugin:org.jetbrains.kotlin.kapt3:javacArguments=$encodedJavacFlags ` + 196 `$kaptProcessorPath ` + 197 `$kaptProcessor ` + 198 `-Xbuild-file=$kotlinBuildFile && ` + 199 `${config.SoongZipCmd} -jar -write_if_changed -o $out -C $kaptDir/stubs -D $kaptDir/stubs && ` + 200 `rm -rf "$srcJarDir"`, 201 CommandDeps: []string{ 202 "${config.KotlincCmd}", 203 "${config.KotlinCompilerJar}", 204 "${config.KotlinKaptJar}", 205 "${config.GenKotlinBuildFileCmd}", 206 "${config.SoongZipCmd}", 207 "${config.ZipSyncCmd}", 208 }, 209 Rspfile: "$out.rsp", 210 RspfileContent: `$in`, 211 Restat: true, 212 }, 213 "kotlincFlags", "encodedJavacFlags", "kaptProcessorPath", "kaptProcessor", 214 "classpath", "srcJars", "commonSrcFilesArg", "srcJarDir", "kaptDir", "kotlinJvmTarget", 215 "kotlinBuildFile", "name", "classesJarOut") 216 217// kotlinKapt performs Kotlin-compatible annotation processing. It takes .kt and .java sources and srcjars, and runs 218// annotation processors over all of them, producing a srcjar of generated code in outputFile. The srcjar should be 219// added as an additional input to kotlinc and javac rules, and the javac rule should have annotation processing 220// disabled. 221func kotlinKapt(ctx android.ModuleContext, srcJarOutputFile, resJarOutputFile android.WritablePath, 222 srcFiles, commonSrcFiles, srcJars android.Paths, 223 flags javaBuilderFlags) { 224 225 srcFiles = append(android.Paths(nil), srcFiles...) 226 227 var deps android.Paths 228 deps = append(deps, flags.kotlincClasspath...) 229 deps = append(deps, flags.kotlincDeps...) 230 deps = append(deps, srcJars...) 231 deps = append(deps, flags.processorPath...) 232 deps = append(deps, commonSrcFiles...) 233 234 commonSrcsList := kotlinCommonSrcsList(ctx, commonSrcFiles) 235 commonSrcFilesArg := "" 236 if commonSrcsList.Valid() { 237 deps = append(deps, commonSrcsList.Path()) 238 commonSrcFilesArg = "--common_srcs " + commonSrcsList.String() 239 } 240 241 kaptProcessorPath := flags.processorPath.FormRepeatedClassPath("-P plugin:org.jetbrains.kotlin.kapt3:apclasspath=") 242 243 kaptProcessor := "" 244 for i, p := range flags.processors { 245 if i > 0 { 246 kaptProcessor += " " 247 } 248 kaptProcessor += "-P plugin:org.jetbrains.kotlin.kapt3:processors=" + p 249 } 250 251 encodedJavacFlags := kaptEncodeFlags([][2]string{ 252 {"-source", flags.javaVersion.String()}, 253 {"-target", flags.javaVersion.String()}, 254 }) 255 256 kotlinName := filepath.Join(ctx.ModuleDir(), ctx.ModuleSubDir(), ctx.ModuleName()) 257 kotlinName = strings.ReplaceAll(kotlinName, "/", "__") 258 259 classpathRspFile := android.PathForModuleOut(ctx, "kapt", "classpath.rsp") 260 android.WriteFileRule(ctx, classpathRspFile, strings.Join(flags.kotlincClasspath.Strings(), "\n")) 261 deps = append(deps, classpathRspFile) 262 263 // First run kapt to generate .java stubs from .kt files 264 kaptStubsJar := android.PathForModuleOut(ctx, "kapt", "stubs.jar") 265 ctx.Build(pctx, android.BuildParams{ 266 Rule: kaptStubs, 267 Description: "kapt stubs", 268 Output: kaptStubsJar, 269 Inputs: srcFiles, 270 Implicits: deps, 271 Args: map[string]string{ 272 "classpath": classpathRspFile.String(), 273 "kotlincFlags": flags.kotlincFlags, 274 "commonSrcFilesArg": commonSrcFilesArg, 275 "srcJars": strings.Join(srcJars.Strings(), " "), 276 "srcJarDir": android.PathForModuleOut(ctx, "kapt", "srcJars").String(), 277 "kotlinBuildFile": android.PathForModuleOut(ctx, "kapt", "build.xml").String(), 278 "kaptProcessorPath": strings.Join(kaptProcessorPath, " "), 279 "kaptProcessor": kaptProcessor, 280 "kaptDir": android.PathForModuleOut(ctx, "kapt/gen").String(), 281 "encodedJavacFlags": encodedJavacFlags, 282 "name": kotlinName, 283 "classesJarOut": resJarOutputFile.String(), 284 }, 285 }) 286 287 // Then run turbine to perform annotation processing on the stubs and any .java srcFiles. 288 javaSrcFiles := srcFiles.FilterByExt(".java") 289 turbineSrcJars := append(android.Paths{kaptStubsJar}, srcJars...) 290 TurbineApt(ctx, srcJarOutputFile, resJarOutputFile, javaSrcFiles, turbineSrcJars, flags) 291} 292 293// kapt converts a list of key, value pairs into a base64 encoded Java serialization, which is what kapt expects. 294func kaptEncodeFlags(options [][2]string) string { 295 buf := &bytes.Buffer{} 296 297 binary.Write(buf, binary.BigEndian, uint32(len(options))) 298 for _, option := range options { 299 binary.Write(buf, binary.BigEndian, uint16(len(option[0]))) 300 buf.WriteString(option[0]) 301 binary.Write(buf, binary.BigEndian, uint16(len(option[1]))) 302 buf.WriteString(option[1]) 303 } 304 305 header := &bytes.Buffer{} 306 header.Write([]byte{0xac, 0xed, 0x00, 0x05}) // java serialization header 307 308 if buf.Len() < 256 { 309 header.WriteByte(0x77) // blockdata 310 header.WriteByte(byte(buf.Len())) 311 } else { 312 header.WriteByte(0x7a) // blockdatalong 313 binary.Write(header, binary.BigEndian, uint32(buf.Len())) 314 } 315 316 return base64.StdEncoding.EncodeToString(append(header.Bytes(), buf.Bytes()...)) 317} 318