Remove old gradle files
Bug: 270105162
Change-Id: Id7b5c1b2df15cf11e19280bdd2ddc2f3ae4a66b9
diff --git a/gradle.properties b/gradle.properties
deleted file mode 100644
index 4bd94ac..0000000
--- a/gradle.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-# for details. All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8
-kotlin.daemon.jvmargs=-Xmx3g -Dkotlin.js.compiler.legacy.force_enabled=true
-systemProp.file.encoding=UTF-8
-
-# Enable new incremental compilation
-kotlin.incremental.useClasspathSnapshot=true
-
-org.gradle.parallel=true
-org.gradle.caching=false
-
-# Do not download any jdks or detect them. We provide them
-org.gradle.java.installations.auto-detect=false
-org.gradle.java.installations.auto-download=false
diff --git a/old.gradle.deprecated b/old.gradle.deprecated
deleted file mode 100644
index f7b3a44..0000000
--- a/old.gradle.deprecated
+++ /dev/null
@@ -1,1844 +0,0 @@
-// Copyright (c) 2016, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-
-
-import net.ltgt.gradle.errorprone.CheckSeverity
-import org.gradle.internal.os.OperatingSystem
-import tasks.DownloadDependency
-
-plugins {
- id "net.ltgt.errorprone" version "2.0.2"
-}
-
-apply plugin: 'java'
-apply plugin: 'idea'
-
-ext {
- // When updating dependencies also update and run
- // tools/create_local_maven_with_dependencies.py
- androidSupportVersion = '25.4.0'
- asmVersion = '9.5' // When updating update tools/asmifier.py, build.src and Toolhelper as well.
- javassistVersion = '3.29.2-GA'
- espressoVersion = '3.0.0'
- fastutilVersion = '7.2.1'
- guavaVersion = '31.1-jre'
- gsonVersion = '2.10.1'
- junitVersion = '4.13-beta-2'
- mockitoVersion = '2.10.0'
- // The kotlin version is only here to specify the kotlin language level,
- // all kotlin compilations are done in tests.
- kotlinVersion = '1.8.0'
- kotlinExtMetadataJVMVersion = '0.7.0'
- smaliVersion = '3.0.3'
- errorproneVersion = '2.18.0'
- testngVersion = '6.10'
-}
-
-repositories {
- maven {
- url uri('file:third_party/dependencies')
- }
-}
-
-if (project.hasProperty('with_code_coverage')) {
- apply plugin: 'jacoco'
-}
-
-// Custom source set for example tests and generated tests.
-sourceSets {
- main {
- java {
- srcDirs = ['src/main/java', 'src/keepanno/java']
- // Exclude in old setup, resource shrinker is only compiled into R8 with 8.0
- exclude 'com/android/tools/r8/utils/resourceshrinker/*.java'
- }
- resources {
- srcDirs "third_party/api_database/api_database"
- }
- }
- main17 {
- java {
- srcDirs = ['src/main/java', 'src/keepanno/java']
- // Exclude in old setup, resource shrinker is only compiled into R8 with 8.0
- exclude 'com/android/tools/r8/utils/resourceshrinker/*.java'
- }
- resources {
- srcDirs "third_party/api_database/api_database"
- }
- }
- test {
- java {
- srcDirs = [
- 'src/test/java',
- 'src/test/bootstrap',
- 'build/generated/test/java',
- ]
- }
- }
- apiUsageSample {
- java {
- srcDirs = ['src/test/apiUsageSample', 'src/main/java']
- include 'com/android/tools/apiusagesample/*.java'
- include 'com/android/tools/r8/BaseCompilerCommandParser.java'
- include 'com/android/tools/r8/D8CommandParser.java'
- include 'com/android/tools/r8/R8CommandParser.java'
- include 'com/android/tools/r8/utils/FlagFile.java'
- }
- }
- cfSegments {
- java {
- srcDirs = ['third_party/classlib/java', 'src/cf_segments/java']
- }
- output.resourcesDir = 'build/classes/cfSegments'
- }
- debugTestResources {
- java {
- srcDirs = ['src/test/debugTestResources']
- }
- output.resourcesDir = 'build/classes/debugTestResources'
- }
- debugTestResourcesJava8 {
- java {
- srcDirs = ['src/test/debugTestResourcesJava8']
- }
- output.resourcesDir = 'build/classes/debugTestResourcesJava8'
- }
- examplesJava9 {
- java {
- srcDirs = ['src/test/examplesJava9']
- }
- }
- examplesJava10 {
- java {
- srcDirs = ['src/test/examplesJava10']
- }
- }
- examplesJava11 {
- java {
- srcDirs = ['src/test/examplesJava11']
- }
- }
- examplesJava17 {
- java {
- srcDirs = ['src/test/examplesJava17']
- }
- }
- examplesJava20 {
- java {
- srcDirs = ['src/test/examplesJava20']
- }
- }
- keepanno {
- java {
- srcDirs = ['src/keepanno/java']
- include 'com/android/tools/r8/keepanno/annotations/*.java'
- }
- }
-}
-
-// Ensure importing into IntelliJ IDEA use the same output directories as Gradle. In tests we
-// use the output path for tests (ultimately through ToolHelper.getClassPathForTests()) and
-// therefore these paths need to be the same. See https://youtrack.jetbrains.com/issue/IDEA-175172
-// for context.
-idea {
- sourceSets.all { SourceSet sources ->
- module {
- if (sources.name == "main") {
- sourceDirs += sources.java.srcDirs
- outputDir sources.output.classesDirs[0]
- } else {
- testSourceDirs += sources.java.srcDirs
- testOutputDir sources.output.classesDirs[0]
- }
- }
- }
-}
-
-dependencies {
- implementation "com.google.code.gson:gson:$gsonVersion"
- // Include all of guava when compiling the code, but exclude annotations that we don't
- // need from the packaging.
- compileOnly("com.google.guava:guava:$guavaVersion")
- implementation("com.google.guava:guava:$guavaVersion", {
- exclude group: 'com.google.errorprone'
- exclude group: 'com.google.code.findbugs'
- exclude group: 'com.google.j2objc'
- exclude group: 'org.codehaus.mojo'
- exclude group: 'com.google.guava', module: 'listenablefuture'
- exclude group: 'com.google.guava', module: 'failureaccess'
- })
- implementation group: 'it.unimi.dsi', name: 'fastutil', version: fastutilVersion
- implementation "org.jetbrains.kotlinx:kotlinx-metadata-jvm:$kotlinExtMetadataJVMVersion"
- implementation group: 'org.ow2.asm', name: 'asm', version: asmVersion
- implementation group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
- implementation group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
- implementation group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
- implementation group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
-
- main17Implementation "com.google.code.gson:gson:$gsonVersion"
- // Include all of guava when compiling the code, but exclude annotations that we don't
- // need from the packaging.
- main17CompileOnly("com.google.guava:guava:$guavaVersion")
- main17Implementation("com.google.guava:guava:$guavaVersion", {
- exclude group: 'com.google.errorprone'
- exclude group: 'com.google.code.findbugs'
- exclude group: 'com.google.j2objc'
- exclude group: 'org.codehaus.mojo'
- })
- main17Implementation group: 'it.unimi.dsi', name: 'fastutil', version: fastutilVersion
- main17Implementation "org.jetbrains.kotlinx:kotlinx-metadata-jvm:$kotlinExtMetadataJVMVersion"
- main17Implementation group: 'org.ow2.asm', name: 'asm', version: asmVersion
- main17Implementation group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
- main17Implementation group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
- main17Implementation group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
- main17Implementation group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
-
- testCompile "junit:junit:$junitVersion"
- testCompile "com.google.guava:guava:$guavaVersion"
- testCompile "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
- testCompile "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
- testCompile group: 'com.android.tools.smali', name: 'smali', version: smaliVersion
- testCompile files('third_party/jasmin/jasmin-2.4.jar')
- testCompile files('third_party/jdwp-tests/apache-harmony-jdwp-tests-host.jar')
- testCompile files('third_party/ddmlib/ddmlib.jar')
- testCompile group: 'org.ow2.asm', name: 'asm', version: asmVersion
- testCompile group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
- testCompile group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
- testCompile group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
- testCompile group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
- testCompile group: 'it.unimi.dsi', name: 'fastutil', version: fastutilVersion
- testCompile group: 'org.javassist', name: 'javassist', version: javassistVersion
-
- apiUsageSampleCompile sourceSets.main.output
- apiUsageSampleCompile "com.google.guava:guava:$guavaVersion"
- errorprone("com.google.errorprone:error_prone_core:$errorproneVersion")
-
- keepannoCompile group: 'org.ow2.asm', name: 'asm', version: asmVersion
- keepannoCompile "com.google.guava:guava:$guavaVersion"
-}
-
-def r8LibPath = "$buildDir/libs/r8lib.jar"
-def r8LibExludeDepsPath = "$buildDir/libs/r8lib-exclude-deps.jar"
-def r8DesugaredPath = "$buildDir/libs/r8desugared.jar"
-def r8LibGeneratedKeepRulesPath = "$buildDir/generated/keep.txt"
-def r8LibTestPath = "$buildDir/classes/r8libtest"
-def java11ClassFiles = "$buildDir/classes/java/mainJava11"
-def r8RetracePath = "$buildDir/libs/r8retrace.jar"
-def r8RetraceExludeDepsPath = "$buildDir/libs/r8retrace-exclude-deps.jar"
-
-def osString = OperatingSystem.current().isLinux() ? "linux" :
- OperatingSystem.current().isMacOsX() ? "mac" : "windows"
-
-def cloudDependencies = [
- "tests" : [
- "2017-10-04/art",
- "2016-12-19/art"
- ],
- "third_party": [
- "aapt2",
- "android_cts_baseline",
- "android_jar/libcore_latest",
- "android_jar/lib-v14",
- "android_jar/lib-v15",
- "android_jar/lib-v19",
- "android_jar/lib-v21",
- "android_jar/lib-v22",
- "android_jar/lib-v23",
- "android_jar/lib-v24",
- "android_jar/lib-v25",
- "android_jar/lib-v26",
- "android_jar/lib-v27",
- "android_jar/lib-v28",
- "android_jar/lib-v29",
- "android_jar/lib-v30",
- "android_jar/lib-v31",
- "android_jar/lib-v32",
- "android_jar/lib-v33",
- "android_jar/lib-v34",
- "android_jar/lib-master",
- "api_database/api_database",
- "api-outlining/simple-app-dump",
- "binary_compatibility_tests/compiler_api_tests",
- "bundletool/bundletool-1.11.0",
- "core-lambda-stubs",
- "dagger/2.41",
- "dart-sdk",
- "ddmlib",
- "examples",
- "examplesAndroidN",
- "examplesAndroidO",
- "examplesAndroidOLegacy",
- "examplesAndroidOGenerated",
- "examplesAndroidP",
- "examplesAndroidPGenerated",
- "gradle/gradle",
- "google/google-java-format/1.14.0",
- "google-java-format",
- "gson/gson-2.10.1",
- "guava/guava-32.1.2-android",
- "guava/guava-32.1.2-jre",
- "jacoco/0.8.2",
- "jacoco/0.8.6",
- "jasmin",
- "junit",
- "jdwp-tests",
- "jsr223-api-1.0",
- "rhino-1.7.10",
- "rhino-android-1.1.1",
- "kotlin/kotlin-compiler-1.3.72",
- "kotlin/kotlin-compiler-1.4.20",
- "kotlin/kotlin-compiler-1.5.0",
- "kotlin/kotlin-compiler-1.6.0",
- "kotlin/kotlin-compiler-1.7.0",
- "kotlin/kotlin-compiler-1.8.0",
- "kotlinx-coroutines-1.3.6",
- "kotlinR8TestResources",
- "multidex",
- "openjdk/custom_conversion",
- "openjdk/openjdk-rt-1.8",
- "openjdk/desugar_jdk_libs",
- "openjdk/desugar_jdk_libs_11",
- "openjdk/desugar_jdk_libs_releases/1.0.9",
- "openjdk/desugar_jdk_libs_releases/1.0.10",
- "openjdk/desugar_jdk_libs_releases/1.1.0",
- "openjdk/desugar_jdk_libs_releases/1.1.1",
- "openjdk/desugar_jdk_libs_releases/1.1.5",
- "openjdk/desugar_jdk_libs_releases/2.0.3",
- "openjdk/jdk-11-test",
- "opensource-apps/tivi",
- "proguard/proguard5.2.1",
- "proguard/proguard6.0.1",
- "proguard/proguard-7.0.0",
- "proguard/proguard-7.3.2",
- "retrace_benchmark",
- "retrace/binary_compatibility",
- "r8",
- "r8-releases/2.0.74",
- "r8-releases/3.2.54",
- "r8mappings",
- "smali"
- ],
- // All dex-vms have a fixed OS of Linux, as they are only supported on Linux, and will be run in a Docker
- // container on other platforms where supported.
- "tools" : [
- "linux/art",
- "linux/art-5.1.1",
- "linux/art-6.0.1",
- "linux/art-7.0.0",
- "linux/art-8.1.0",
- "linux/art-9.0.0",
- "linux/art-10.0.0",
- "linux/host/art-12.0.0-beta4",
- "linux/host/art-13.0.0",
- "linux/host/art-14.0.0-beta3",
- "linux/host/art-master",
- "linux/dalvik",
- "linux/dalvik-4.0.4",
- ]
-]
-
-def cloudSystemDependencies = [
- linux: [
- "third_party": ["openjdk/openjdk-9.0.4/linux",
- "openjdk/jdk8/linux-x86",
- "openjdk/jdk-11/linux",
- "openjdk/jdk-17/linux",
- "openjdk/jdk-20/linux"],
- ],
- osx: [
- "third_party": ["openjdk/openjdk-9.0.4/osx",
- "openjdk/jdk8/darwin-x86",
- "openjdk/jdk-11/osx",
- "openjdk/jdk-17/osx",
- "openjdk/jdk-20/osx"],
- ],
- windows: [
- "third_party": ["openjdk/openjdk-9.0.4/windows",
- "openjdk/jdk-11/windows",
- "openjdk/jdk-17/windows",
- "openjdk/jdk-20/windows"],
- ],
-]
-
-if (OperatingSystem.current().isWindows()) {
- cloudSystemDependencies.windows.each { entry ->
- cloudDependencies.get(entry.key).addAll(entry.value)
- }
-} else if (OperatingSystem.current().isLinux()) {
- cloudSystemDependencies.linux.each { entry ->
- cloudDependencies.get(entry.key).addAll(entry.value)
- }
-} else if (OperatingSystem.current().isMacOsX()) {
- cloudSystemDependencies.osx.each { entry ->
- cloudDependencies.get(entry.key).addAll(entry.value)
- }
-} else {
- println "WARNING: Unsupported system: " + OperatingSystem.current()
-}
-
-def getDownloadDepsTaskName(entryKey, entryFile) {
- return "download_deps_${entryKey}_${entryFile.replace('/', '_').replace('\\', '_')}"
-}
-
-cloudDependencies.each { entry ->
- entry.value.each { entryFile ->
- task (getDownloadDepsTaskName(entry.key, entryFile), type: DownloadDependency) {
- type DownloadDependency.Type.GOOGLE_STORAGE
- dependency "${entry.key}/${entryFile}"
- }
- }
-}
-
-def x20Dependencies = [
- "third_party": [
- "benchmarks/kotlin-benches",
- "chrome/chrome_200430",
- "chrome/monochrome_public_minimal_apks/chrome_200520",
- "chrome/clank_google3_prebuilt",
- "classlib",
- "cf_segments",
- "desugar/desugar_20180308",
- "internal/issue-127524985",
- "framework",
- "gmail/gmail_android_180826.15",
- "gmscore/gmscore_v10",
- "gmscore/latest",
- "nest/nest_20180926_7c6cfb",
- "proguard/proguard_internal_159423826",
- "proguardsettings",
- "proto",
- "protobuf-lite",
- "retrace_internal",
- "youtube/youtube.android_17.19"
- ],
-]
-
-x20Dependencies.each { entry ->
- entry.value.each { entryFile ->
- task "${getDownloadDepsTaskName(entry.key, entryFile)}"(type: DownloadDependency) {
- type DownloadDependency.Type.X20
- dependency "${entry.key}/${entryFile}"
- }
- }
-}
-
-task downloadOpenJDKrt {
- cloudDependencies.each { entry ->
- entry.value.each { entryFile ->
- if (entryFile.contains("openjdk-rt")) {
- dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
- }
- }
- }
-}
-
-task downloadAndroidCts {
- cloudDependencies.each { entry ->
- entry.value.each { entryFile ->
- if (entryFile.contains("android_cts_baseline")) {
- dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
- }
- }
- }
-}
-
-task downloadCloudDeps() {
- cloudDependencies.each { entry ->
- entry.value.each { entryFile ->
- dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
- }
- }
-}
-
-task downloadX20Deps() {
- x20Dependencies.each { entry ->
- entry.value.each { entryFile ->
- dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
- }
- }
-}
-
-task downloadDeps {
- dependsOn downloadCloudDeps
- if (!project.hasProperty('no_internal')) {
- dependsOn downloadX20Deps
- }
-}
-
-allprojects {
- sourceCompatibility = JavaVersion.VERSION_1_8
- targetCompatibility = JavaVersion.VERSION_1_8
-}
-
-// TODO(ricow): Remove debug prints
-println("NOTE: Current operating system: " + OperatingSystem.current())
-println("NOTE: Current operating system isWindows: " + OperatingSystem.current().isWindows())
-
-// Check if running with the JDK location from tools/jdk.py.
-if (OperatingSystem.current().isWindows()) {
- println "NOTE: Running with JDK: " + org.gradle.internal.jvm.Jvm.current().javaHome
- compileJava.options.encoding = "UTF-8"
- compileTestJava.options.encoding = "UTF-8"
-} else {
- def javaHomeOut = new StringBuilder()
- def javaHomeErr = new StringBuilder()
- def javaHomeProc = './tools/jdk.py'.execute([], projectDir)
- javaHomeProc.waitForProcessOutput(javaHomeOut, javaHomeErr)
- def jdkHome = new File(javaHomeOut.toString().trim())
- if (!jdkHome.exists()) {
- println "WARNING: Failed to find the ./tools/jdk.py specified JDK: " + jdkHome
- } else if (jdkHome != org.gradle.internal.jvm.Jvm.current().javaHome) {
- println("WARNING: Gradle is running in a non-pinned Java"
- + ". Gradle Java Home: " + org.gradle.internal.jvm.Jvm.current().javaHome
- + ". Expected: " + jdkHome)
- } else {
- println("NOTE: Running with jdk from tools/jdk.py: " + jdkHome)
- }
-}
-
-compileJava.dependsOn downloadCloudDeps
-
-sourceSets.configureEach { sourceSet ->
- tasks.named(sourceSet.compileJavaTaskName).configure {
- // Default disable errorprone (enabled and setup below).
- options.errorprone.enabled = false
- options.compilerArgs << '-Xlint:unchecked'
- // Run all compilation tasks in a forked subprocess.
- options.fork = true
- // Javac often runs out of stack space when compiling the tests.
- // Increase the stack size for the javac process.
- options.forkOptions.jvmArgs << "-Xss256m"
- // Test compilation is sometimes hitting the default limit at 1g, increase it.
- options.forkOptions.jvmArgs << "-Xmx3g"
- }
-}
-
-def setJdkCompilationWithCompatibility(String sourceSet, String javaHome, JavaVersion compatibility, boolean enablePreview) {
- tasks.named(sourceSet).get().configure {
- def jdkDir = "third_party/openjdk/${javaHome}/"
- options.fork = true
- options.forkOptions.jvmArgs = []
- if (enablePreview) {
- options.compilerArgs.add('--enable-preview')
- }
- if (OperatingSystem.current().isLinux()) {
- dependsOn getDownloadDepsTaskName("third_party", "openjdk/" + javaHome + "/linux")
- options.forkOptions.javaHome = file(jdkDir + 'linux')
- } else if (OperatingSystem.current().isMacOsX()) {
- dependsOn getDownloadDepsTaskName("third_party", "openjdk/" + javaHome + "/osx")
- options.forkOptions.javaHome = compatibility > JavaVersion.VERSION_1_9
- ? file(jdkDir + 'osx/Contents/Home')
- : file(jdkDir + 'osx')
- } else {
- dependsOn getDownloadDepsTaskName("third_party", "openjdk/" + javaHome + "/windows")
- options.forkOptions.javaHome = file(jdkDir + 'windows')
- }
- sourceCompatibility = compatibility
- targetCompatibility = compatibility
- }
-}
-
-setJdkCompilationWithCompatibility(
- sourceSets.main.compileJavaTaskName,
- 'jdk-11',
- JavaVersion.VERSION_11,
- false);
-
-setJdkCompilationWithCompatibility(
- sourceSets.examplesJava9.compileJavaTaskName,
- 'openjdk-9.0.4',
- JavaVersion.VERSION_1_9,
- false)
-setJdkCompilationWithCompatibility(
- sourceSets.examplesJava10.compileJavaTaskName,
- 'jdk-11',
- JavaVersion.VERSION_1_10,
- false)
-setJdkCompilationWithCompatibility(
- sourceSets.main17.compileJavaTaskName,
- 'jdk-17',
- JavaVersion.VERSION_17,
- false)
-setJdkCompilationWithCompatibility(
- sourceSets.examplesJava11.compileJavaTaskName,
- 'jdk-11',
- JavaVersion.VERSION_11,
- false)
-setJdkCompilationWithCompatibility(
- sourceSets.examplesJava17.compileJavaTaskName,
- 'jdk-17',
- JavaVersion.VERSION_17,
- false)
-setJdkCompilationWithCompatibility(
- sourceSets.examplesJava20.compileJavaTaskName,
- 'jdk-20',
- // TODO(b/218293990): Update Gradle to get JavaVersion.VERSION_18.
- JavaVersion.VERSION_17,
- false)
-
-if (!project.hasProperty('without_error_prone') &&
- // Don't enable error prone on Java 8 as the plugin setup does not support it.
- !org.gradle.internal.jvm.Jvm.current().javaVersion.java8) {
- compileJava {
-
- // Enable error prone for D8/R8 main sources.
- options.errorprone.enabled = true
-
- // Make all warnings errors. Warnings that we have chosen not to fix (or suppress) are
- // disabled outright below.
- options.compilerArgs << "-Werror"
-
- // Increase number of reported errors to 1000 (default is 100).
- options.compilerArgs << "-Xmaxerrs"
- options.compilerArgs << "1000"
-
- // Non-default / Experimental checks - explicitly enforced.
- options.errorprone.check('RemoveUnusedImports', CheckSeverity.ERROR)
- options.errorprone.check('InconsistentOverloads', CheckSeverity.ERROR)
- options.errorprone.check('MissingDefault', CheckSeverity.ERROR)
- options.errorprone.check('MultipleTopLevelClasses', CheckSeverity.ERROR)
- options.errorprone.check('NarrowingCompoundAssignment', CheckSeverity.ERROR)
-
- // Warnings that cause unwanted edits (e.g., inability to write informative asserts).
- options.errorprone.check('AlreadyChecked', CheckSeverity.OFF)
-
- // JavaDoc related warnings. Would be nice to resolve but of no real consequence.
- options.errorprone.check('InvalidLink', CheckSeverity.OFF)
- options.errorprone.check('InvalidBlockTag', CheckSeverity.OFF)
- options.errorprone.check('InvalidInlineTag', CheckSeverity.OFF)
- options.errorprone.check('EmptyBlockTag', CheckSeverity.OFF)
- options.errorprone.check('MissingSummary', CheckSeverity.OFF)
- options.errorprone.check('UnrecognisedJavadocTag', CheckSeverity.OFF)
- options.errorprone.check('AlmostJavadoc', CheckSeverity.OFF)
-
- // Moving away from identity and canonical items is not planned.
- options.errorprone.check('IdentityHashMapUsage', CheckSeverity.OFF)
- }
-}
-
-task consolidatedLicense {
- def license = new File(new File(buildDir, 'generatedLicense'), 'LICENSE')
-
- inputs.files files('LICENSE', 'LIBRARY-LICENSE') + fileTree(dir: 'library-licensing')
- def runtimeClasspath = configurations.findByName("runtimeClasspath")
- inputs.files { runtimeClasspath.getResolvedConfiguration().files }
-
- outputs.files license
-
- doLast {
- def dependencies = []
- runtimeClasspath.resolvedConfiguration.resolvedArtifacts.each {
- def identifier = (ModuleComponentIdentifier) it.id.componentIdentifier
- dependencies.add("${identifier.group}:${identifier.module}")
- }
- def libraryLicenses = file('LIBRARY-LICENSE').text
- dependencies.each {
- if (!libraryLicenses.contains("- artifact: $it")) {
- throw new GradleException("No license for $it in LIBRARY_LICENSE")
- }
- }
-
- license.getParentFile().mkdirs()
- license.createNewFile()
- license.text = "This file lists all licenses for code distributed.\n"
- license.text += "All non-library code has the following 3-Clause BSD license.\n"
- license.text += "\n"
- license.text += "\n"
- license.text += file('LICENSE').text
- license.text += "\n"
- license.text += "\n"
- license.text += "Summary of distributed libraries:\n"
- license.text += "\n"
- license.text += libraryLicenses
- license.text += "\n"
- license.text += "\n"
- license.text += "Licenses details:\n"
- fileTree(dir: 'library-licensing').getFiles().stream().sorted().forEach { file ->
- license.text += "\n"
- license.text += "\n"
- license.text += file.text
- }
- }
-}
-
-def repackageDepFile(file) {
- if (file.getName().endsWith('.jar')) {
- return zipTree(file).matching {
- exclude '**/module-info.class'
- exclude 'META-INF/maven/**'
- exclude 'META-INF/LICENSE.txt'
- exclude 'META-INF/MANIFEST.MF'
- }
- } else {
- return fileTree(file)
- }
-}
-
-task repackageDeps(type: Jar) {
- dependsOn downloadCloudDeps
- dependsOn project.configurations.runtimeClasspath
- project.configurations.runtimeClasspath.forEach {
- from repackageDepFile(it)
- }
- archiveFileName = 'deps_all.jar'
-}
-
-task repackageTestDeps(type: Jar) {
- dependsOn downloadCloudDeps
- dependsOn project.configurations.testCompile
- project.configurations.testCompile.forEach {
- from repackageDepFile(it)
- }
- archiveFileName = 'test_deps_all.jar'
-}
-
-task repackageSources(type: Jar) {
- // If this fails then remove all generated folders from
- // build/classes/java/test that is not {com,dalvik}
- from sourceSets.main.output
- archiveFileName = 'sources_main.jar'
-}
-
-task repackageSources17(type: Jar) {
- from sourceSets.main17.output
- archiveFileName = 'sources_main_17.jar'
-}
-
-def r8CreateTask(name, baseName, sources, includeLibraryLicenses, includeSwissArmyKnife) {
- return tasks.create("r8Create${name}", Jar) {
- entryCompression ZipEntryCompression.STORED
- dependsOn sources
- dependsOn files('LICENSE')
- if (includeLibraryLicenses) {
- from consolidatedLicense.outputs.files
- } else {
- from files('LICENSE')
- }
- from sources.collect { zipTree(it) }
- exclude "$buildDir/classes/**"
- archiveFileName = baseName
- if (includeSwissArmyKnife) {
- manifest {
- attributes 'Main-Class': 'com.android.tools.r8.SwissArmyKnife'
- }
- }
- exclude "META-INF/*.kotlin_module"
- exclude "**/*.kotlin_metadata"
- }
-}
-
-def r8RelocateTask(r8Task, output) {
- return tasks.create("r8Relocate_${r8Task.name}", Exec) {
- dependsOn r8WithDeps
- dependsOn r8Task
- outputs.file output
- workingDir = projectDir
- inputs.files r8Task.outputs.files + r8WithDeps.outputs.files
- commandLine baseCompilerCommandLine([
- "relocator",
- "--input",
- r8Task.outputs.files[0],
- "--output",
- output,
- "--map",
- "com.google.common.**->com.android.tools.r8.com.google.common",
- "--map",
- "com.google.gson.**->com.android.tools.r8.com.google.gson",
- "--map",
- "com.google.thirdparty.**->com.android.tools.r8.com.google.thirdparty",
- "--map",
- "org.objectweb.asm.**->com.android.tools.r8.org.objectweb.asm",
- "--map",
- "it.unimi.dsi.fastutil.**->com.android.tools.r8.it.unimi.dsi.fastutil",
- "--map",
- "kotlin.**->com.android.tools.r8.jetbrains.kotlin",
- "--map",
- "kotlinx.**->com.android.tools.r8.jetbrains.kotlinx",
- "--map",
- "org.jetbrains.**->com.android.tools.r8.org.jetbrains",
- "--map",
- "org.intellij.**->com.android.tools.r8.org.intellij",
- "--map",
- "org.checkerframework.**->com.android.tools.r8.org.checkerframework"
- ])
- }
-}
-
-task r8WithDeps {
- dependsOn repackageSources
- dependsOn repackageDeps
- inputs.files ([repackageSources.outputs, repackageDeps.outputs])
- def r8Task = r8CreateTask(
- 'WithDeps',
- 'r8_with_deps.jar',
- repackageSources.outputs.files + repackageDeps.outputs.files,
- true,
- true)
- dependsOn r8Task
- outputs.files r8Task.outputs.files
-}
-
-task r8WithDeps17 {
- dependsOn repackageSources17
- dependsOn repackageDeps
- inputs.files ([repackageSources17.outputs, repackageDeps.outputs])
- def r8Task = r8CreateTask(
- 'WithDeps17',
- 'r8_with_deps_17.jar',
- repackageSources17.outputs.files + repackageDeps.outputs.files,
- true,
- true)
- dependsOn r8Task
- outputs.files r8Task.outputs.files
-}
-
-task r8WithRelocatedDeps {
- def output = "${buildDir}/libs/r8_with_relocated_deps.jar"
- dependsOn r8RelocateTask(r8WithDeps, output)
- inputs.files r8WithDeps.outputs.files
- outputs.file output
-}
-
-task r8WithRelocatedDeps17 {
- def output = "${buildDir}/libs/r8_with_relocated_deps_17.jar"
- dependsOn r8RelocateTask(r8WithDeps17, output)
- inputs.files r8WithDeps17.outputs.files
- outputs.file output
-}
-
-task r8WithoutDeps {
- dependsOn repackageSources
- inputs.files repackageSources.outputs
- def r8Task = r8CreateTask(
- 'WithoutDeps',
- 'r8_without_deps.jar',
- repackageSources.outputs.files,
- false,
- true)
- dependsOn r8Task
- outputs.files r8Task.outputs.files
-}
-
-task r8(type: Copy) {
- def r8Task = project.hasProperty("exclude_deps")
- ? r8WithoutDeps : r8WithRelocatedDeps
- dependsOn r8Task
- from r8Task.outputs.files[0]
- into file("${buildDir}/libs")
- rename { String fileName -> "r8.jar" }
- outputs.file "${buildDir}/libs/r8.jar"
-}
-
-task r8NoManifestWithoutDeps {
- dependsOn repackageSources
- inputs.files repackageSources.outputs
- def r8Task = r8CreateTask(
- 'NoManifestWithoutDeps',
- 'r8_no_manifest_without_deps.jar',
- repackageSources.outputs.files,
- false,
- false)
- dependsOn r8Task
- outputs.files r8Task.outputs.files
-}
-
-task r8NoManifestWithDeps {
- dependsOn repackageSources
- inputs.files ([repackageSources.outputs, repackageDeps.outputs])
- def r8Task = r8CreateTask(
- 'NoManifestWithDeps',
- 'r8_no_manifest_with_deps.jar',
- repackageSources.outputs.files + repackageDeps.outputs.files,
- true,
- false)
- dependsOn r8Task
- outputs.files r8Task.outputs.files
-}
-
-task r8NoManifestWithRelocatedDeps {
- def output = "${buildDir}/libs/r8_no_manifest_with_relocated_deps.jar"
- dependsOn r8RelocateTask(r8NoManifestWithDeps, output)
- inputs.files r8NoManifestWithDeps.outputs.files
- outputs.file output
-}
-
-task r8NoManifest(type: Copy) {
- def r8Task = project.hasProperty("exclude_deps")
- ? r8NoManifestWithoutDeps : r8NoManifestWithRelocatedDeps
- dependsOn r8Task
- from r8Task.outputs.files[0]
- into file("${buildDir}/libs")
- rename { String fileName -> "r8_no_manifest.jar" }
- outputs.file "${buildDir}/libs/r8_no_manifest.jar"
-}
-
-def baseCompilerCommandLine(compiler, args = []) {
- // Execute r8 commands against a stable r8 with dependencies.
- // TODO(b/139725780): See if we can remove or lower the heap size (-Xmx8g).
- return [org.gradle.internal.jvm.Jvm.current().getJavaExecutable(),
- "-Xmx8g", "-ea", "-jar", r8WithDeps.outputs.files[0]] + compiler + args
-}
-
-def baseR8CommandLine(args = []) {
- // Execute r8 commands against a stable r8 with dependencies.
- return baseCompilerCommandLine("r8", args)
-}
-
-def baseD8CommandLine(args = []) {
- // Execute r8 commands against a stable r8 with dependencies.
- return baseCompilerCommandLine("d8", args)
-}
-
-def r8CfCommandLine(input, output, pgConfs = [], args = ["--release"], libs = []) {
- def allArgs = [
- "--classfile",
- input,
- "--output", output,
- "--pg-map-output", output + ".map",
- "--partition-map-output", output + "_map.zip",
- "--lib", org.gradle.internal.jvm.Jvm.current().javaHome,
- ] + args + libs.collectMany { ["--lib", it] } + pgConfs.collectMany { ["--pg-conf", it] }
- return baseR8CommandLine(allArgs)
-}
-
-def d8CfCommandLine(input, output, args = ["--release"], libs = []) {
- def allArgs = [
- "--classfile",
- input,
- "--output", output,
- "--lib", "third_party/openjdk/openjdk-rt-1.8/rt.jar"
- ] + args + libs.collectMany { ["--lib", it] }
- return baseD8CommandLine(allArgs)
-}
-
-def r8LibCreateTask(
- name, pgConfs = [], r8Task, output, libs = [], classpath = [], excldeps=false, debug=false) {
- return tasks.create("r8Lib${name}", Exec) {
- inputs.files ([pgConfs, r8WithRelocatedDeps.outputs, r8Task.outputs])
- outputs.file output
- dependsOn downloadOpenJDKrt
- dependsOn r8WithRelocatedDeps
- dependsOn r8Task
- commandLine ([
- "python3", "tools/create_r8lib.py",
- "--r8jar", r8Task.outputs.files[0],
- "--output", output]
- + (excldeps ? ['--excldeps-variant'] : [])
- + (debug ? ['--debug-variant'] : [])
- + (pgConfs.collectMany { ["--pg-conf", it] })
- + (libs.collectMany { ["--lib", it] })
- + (classpath.collectMany { ["--classpath", it] }))
- workingDir = projectDir
- }
-}
-
-task testJarSources(type: Jar, dependsOn: [testClasses]) {
- archiveFileName = "r8testsbase.jar"
- from sourceSets.test.output
- // We only want to include tests that use R8 when generating keep rules for applymapping.
- include "com/android/tools/r8/**"
- include "android/**"
- include "dalvik/**"
-}
-
-task testJar(type: Exec) {
- dependsOn r8WithDeps
- dependsOn testJarSources
- def output = "$buildDir/libs/r8tests.jar"
- outputs.file output
- workingDir = projectDir
- inputs.files (testJarSources.outputs.files + r8WithDeps.outputs.files)
- commandLine baseCompilerCommandLine([
- "relocator",
- "--input",
- testJarSources.outputs.files[0],
- "--output",
- output,
- "--map",
- "kotlinx.metadata.**->com.android.tools.r8.jetbrains.kotlinx.metadata"
- ])
-}
-
-task generateR8LibKeepRules(type: Exec) {
- // Depend on r8WithRelocatedDeps to ensure that we do not have external
- // dependencies crossing the boundary.
- dependsOn r8WithDeps
- dependsOn r8NoManifestWithRelocatedDeps
- dependsOn testJar
- dependsOn repackageTestDeps
- dependsOn downloadOpenJDKrt
- inputs.files ([
- r8WithDeps.outputs,
- r8NoManifestWithRelocatedDeps.outputs,
- repackageDeps.outputs,
- repackageTestDeps.outputs,
- testJar.outputs])
- outputs.file r8LibGeneratedKeepRulesPath
- commandLine baseCompilerCommandLine([
- "tracereferences",
- "--keep-rules",
- "--allowobfuscation",
- "--lib",
- "third_party/openjdk/openjdk-rt-1.8/rt.jar",
- "--lib",
- repackageDeps.outputs.files[0],
- "--lib",
- repackageTestDeps.outputs.files[0],
- "--target",
- r8NoManifestWithRelocatedDeps.outputs.files[0],
- "--source",
- testJar.outputs.files[0],
- "--output",
- r8LibGeneratedKeepRulesPath])
- workingDir = projectDir
-}
-
-task R8Lib {
- dependsOn r8LibCreateTask(
- "Main",
- ["src/main/keep.txt", generateR8LibKeepRules.outputs.files[0]],
- r8NoManifestWithRelocatedDeps,
- r8LibPath
- ).dependsOn(generateR8LibKeepRules)
- inputs.files r8NoManifestWithRelocatedDeps.outputs.files
- outputs.file r8LibPath
-}
-
-task R8LibNoDeps {
- dependsOn r8LibCreateTask(
- "MainNoDeps",
- ["src/main/keep.txt"],
- r8NoManifestWithoutDeps,
- r8LibExludeDepsPath,
- [],
- repackageDeps.outputs.files,
- true,
- ).dependsOn(repackageDeps)
- inputs.files ([r8NoManifestWithoutDeps.outputs, repackageDeps.outputs])
- outputs.file r8LibExludeDepsPath
-}
-
-task R8Desugared(type: Exec) {
- dependsOn downloadOpenJDKrt
- dependsOn r8NoManifestWithRelocatedDeps
- inputs.files r8NoManifestWithRelocatedDeps.outputs.files
- commandLine d8CfCommandLine(
- r8NoManifestWithRelocatedDeps.outputs.files[0],
- r8DesugaredPath,
- ["--release"])
- workingDir = projectDir
- outputs.file r8DesugaredPath
-}
-
-task R8Retrace {
- dependsOn R8Lib
- dependsOn r8LibCreateTask(
- "Retrace",
- ["src/main/keep_retrace.txt"],
- R8Lib,
- r8RetracePath,
- [],
- [],
- false,
- true
- ).dependsOn(R8Lib)
- outputs.file r8RetracePath
-}
-
-task R8RetraceNoDeps {
- dependsOn R8LibNoDeps
- dependsOn r8LibCreateTask(
- "RetraceNoDeps",
- ["src/main/keep_retrace.txt"],
- R8LibNoDeps,
- r8RetraceExludeDepsPath,
- [],
- repackageDeps.outputs.files,
- true,
- true,
- ).dependsOn(R8LibNoDeps)
- outputs.file r8RetraceExludeDepsPath
-}
-
-task sourceJar(type: Jar, dependsOn: classes) {
- classifier = 'src'
- from sourceSets.main.allSource
-}
-
-task keepAnnoJar(type: Jar) {
- archiveFileName = "keepanno-annotations.jar"
- from sourceSets.keepanno.output
-}
-
-artifacts {
- archives sourceJar
-}
-
-task createArtTests(type: Exec) {
- def outputDir = "build/generated/test/java/com/android/tools/r8/art"
- def createArtTestsScript = "tools/create_art_tests.py"
- inputs.files files("tests/2017-10-04/art.tar.gz", createArtTestsScript)
- outputs.dir outputDir
- dependsOn downloadDeps
- commandLine "python3", createArtTestsScript
- workingDir = projectDir
-}
-
-compileTestJava {
- dependsOn createArtTests
-}
-
-task buildCfSegments(type: Jar, dependsOn: downloadDeps) {
- from sourceSets.cfSegments.output
- archiveFileName = 'cf_segments.jar'
- destinationDir file('build/libs')
-}
-
-task buildR8ApiUsageSample(type: Jar) {
- from sourceSets.apiUsageSample.output
- archiveFileName = 'r8_api_usage_sample.jar'
- destinationDir file('tests')
-}
-
-task buildApiSampleJars {
- dependsOn buildR8ApiUsageSample
-}
-
-def buildExampleJarsCreateTask(javaVersion, sourceSet) {
- return tasks.create("buildExample${javaVersion}Jars") {
- def examplesDir = file("src/test/examples${javaVersion}")
- examplesDir.eachDir { dir ->
- def name = dir.getName();
- def exampleOutputDir = file("build/test/examples${javaVersion}");
- def jarName = "${name}.jar"
- dependsOn "jar_examples${javaVersion}_${name}"
- task "jar_examples${javaVersion}_${name}"(type: Jar) {
- archiveName = jarName
- destinationDir = exampleOutputDir
- from sourceSet.output
- include "**/" + name + "/**/*.class"
- }
- }
- }
-}
-
-buildExampleJarsCreateTask("Java9", sourceSets.examplesJava9)
-buildExampleJarsCreateTask("Java10", sourceSets.examplesJava10)
-buildExampleJarsCreateTask("Java11", sourceSets.examplesJava11)
-buildExampleJarsCreateTask("Java17", sourceSets.examplesJava17)
-buildExampleJarsCreateTask("Java20", sourceSets.examplesJava20)
-
-task buildExamples {
- if (OperatingSystem.current().isMacOsX() || OperatingSystem.current().isWindows()) {
- logger.lifecycle("WARNING: Testing (including building examples) is only partially supported on your " +
- "platform (" + OperatingSystem.current().getName() + ").")
- } else if (!OperatingSystem.current().isLinux()) {
- logger.lifecycle("WARNING: Testing (including building examples) is not supported on your platform. " +
- "It is fully supported on Linux and partially supported on Mac OS and Windows")
- return;
- }
- dependsOn buildExampleJava9Jars
- dependsOn buildExampleJava10Jars
- dependsOn buildExampleJava11Jars
- dependsOn buildExampleJava17Jars
- dependsOn buildExampleJava20Jars
-}
-
-tasks.withType(Test) {
- println("NOTE: Number of processors " + Runtime.runtime.availableProcessors())
- def userDefinedCoresPerFork = System.getenv('R8_GRADLE_CORES_PER_FORK')
- def processors = Runtime.runtime.availableProcessors()
- // See https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html.
- if (userDefinedCoresPerFork) {
- maxParallelForks = processors.intdiv(userDefinedCoresPerFork.toInteger()) ?: 1
- } else {
- // On normal work machines this seems to give the best test execution time (without freezing)
- maxParallelForks = processors.intdiv(3) ?: 1
- // On low cpu count machines (bots) we under subscribe, so increase the count.
- if (processors == 32) {
- maxParallelForks = 15
- }
- }
- println("NOTE: Max parallel forks " + maxParallelForks)
-
- forkEvery = 0
- if (project.hasProperty('disable_assertions')) {
- enableAssertions = false
- }
- // TODO(b/124091860): Increase the max heap size to avoid OOM when running tests.
- if (project.hasProperty('test_xmx')) {
- maxHeapSize = project.property('test_xmx')
- } else {
- maxHeapSize = "4G"
- }
-}
-
-task generateR8TestKeepRules {
- def path = "build/generated/r8tests-keep.txt"
- outputs.file path
- dependsOn R8Lib
- doLast {
- file(path).write """-keep class ** { *; }
--dontshrink
--dontoptimize
--keepattributes *
--applymapping ${R8Lib.outputs.files[0]}.map
-"""
- }
-}
-
-task buildR8LibCfTestDeps(type: Exec) {
- def outputPath = "build/libs/r8libtestdeps-cf.jar"
- dependsOn downloadDeps
- dependsOn r8NoManifest
- dependsOn R8Lib
- dependsOn generateR8TestKeepRules
- dependsOn testJar
- // Take all .jar files as libraries and append the generated test classes in classes/java/test.
- def addedLibraries = sourceSets.test.runtimeClasspath.findAll { pkg ->
- return pkg.toString().endsWith(".jar")
- } + ["${buildDir}/classes/java/test"]
- inputs.files testJar.outputs.files +
- generateR8TestKeepRules.outputs.files +
- R8Lib.outputs
- commandLine = r8CfCommandLine(
- testJar.outputs.files[0],
- outputPath,
- [generateR8TestKeepRules.outputs.files[0]],
- ["--debug", "--classpath", r8NoManifest.outputs.files[0]],
- r8NoManifest.outputs.files + addedLibraries)
- workingDir = projectDir
- outputs.file outputPath
-}
-
-task configureTestForR8Lib(type: Copy) {
- dependsOn testJar
- inputs.files buildR8LibCfTestDeps.outputs
- dependsOn R8Lib
- delete r8LibTestPath
- from zipTree(buildR8LibCfTestDeps.outputs.files[0])
- def examplesDir = file("build/test")
- if (examplesDir.exists()) {
- examplesDir.eachDir { dir ->
- from ("${buildDir}/test/${dir.getName()}/classes")
- }
- }
- from ("${buildDir}/runtime/examples")
- into r8LibTestPath
- outputs.dir r8LibTestPath
-}
-
-def shouldRetrace() {
- return project.hasProperty('r8lib') || project.hasProperty('r8lib_no_deps')
-}
-
-def retrace(Throwable exception) {
- def out = new StringBuffer()
- def err = new StringBuffer()
- def command = "python3 tools/retrace.py --quiet"
- def header = "RETRACED STACKTRACE";
- out.append("\n--------------------------------------\n")
- out.append("${header}\n")
- out.append("--------------------------------------\n")
- Process process = command.execute()
- def processIn = new PrintStream(process.getOut())
- process.consumeProcessOutput(out, err)
- exception.printStackTrace(processIn)
- processIn.flush()
- processIn.close()
- def errorDuringRetracing = process.waitFor() != 0
- if (errorDuringRetracing) {
- out.append("ERROR DURING RETRACING\n")
- out.append(err.toString())
- }
- if (project.hasProperty('print_obfuscated_stacktraces') || errorDuringRetracing) {
- out.append("\n\n--------------------------------------\n")
- out.append("OBFUSCATED STACKTRACE\n")
- out.append("--------------------------------------\n")
- }
- return out.toString()
-}
-
-def printStackTrace(TestResult result) {
- filterStackTraces(result)
- if (shouldRetrace()) {
- def exception = new Exception(retrace(result.exception))
- exception.setStackTrace([] as StackTraceElement[])
- result.exceptions.add(0, exception)
- }
-}
-
-def filterStackTraces(TestResult result) {
- for (Throwable throwable : result.getExceptions()) {
- filterStackTrace(throwable)
- }
-}
-
-// It would be nice to do this in a non-destructive way...
-def filterStackTrace(Throwable exception) {
- if (!project.hasProperty('print_full_stacktraces')) {
- def elements = []
- def skipped = []
- for (StackTraceElement element : exception.getStackTrace()) {
- if (element.toString().contains("com.android.tools.r8")) {
- elements.addAll(skipped)
- elements.add(element)
- skipped.clear()
- } else {
- skipped.add(element)
- }
- }
- exception.setStackTrace(elements as StackTraceElement[])
- }
-}
-
-def printAllStackTracesToFile(List<Throwable> exceptions, File out) {
- new PrintStream(new FileOutputStream(out)).withCloseable {printer ->
- exceptions.forEach { it.printStackTrace(printer) }
- }
-}
-
-static def escapeHtml(String string) {
- return string.replace("&", "&").replace("<", "<").replace(">", ">")
-}
-
-static def urlEncode(String string) {
- // Not sure why, but the + also needs to be converted to have working links.
- return URLEncoder.encode(string, "UTF-8").replace("+","%20")
-}
-
-def ensureDir(File dir) {
- dir.mkdirs()
- return dir
-}
-
-// Some of our test parameters have new lines :-( We really don't want test names to span lines.
-static def sanitizedTestName(testDesc) {
- if (testDesc.getName().contains("\n")) {
- throw new RuntimeException("Unsupported use of newline in test name: '${testDesc.getName()}'")
- }
- return testDesc.getName()
-}
-
-static def desanitizedTestName(testName) {
- return testName
-}
-
-def getTestReportEntryDir(reportDir, testDesc) {
- return ensureDir(reportDir.toPath()
- .resolve(testDesc.getClassName())
- .resolve(sanitizedTestName(testDesc))
- .toFile())
-}
-
-def getTestReportEntryURL(reportDir, testDesc) {
- def classDir = urlEncode(testDesc.getClassName())
- def testDir = urlEncode(sanitizedTestName(testDesc))
- return "file://${reportDir}/${classDir}/${testDir}"
-}
-
-def getTestResultEntryOutputFile(reportDir, testDesc, fileName) {
- def dir = getTestReportEntryDir(reportDir, testDesc).toPath()
- return dir.resolve(fileName).toFile()
-}
-
-def withTestResultEntryWriter(reportDir, testDesc, fileName, append, fn) {
- def file = getTestResultEntryOutputFile(reportDir, testDesc, fileName)
- new FileWriter(file, append).withCloseable fn
-}
-
-static def getGitBranchName() {
- def out = new StringBuilder()
- def err = new StringBuilder()
- def proc = "git rev-parse --abbrev-ref HEAD".execute()
- proc.waitForProcessOutput(out, err)
- return out.toString().trim()
-}
-
-static def getFreshTestReportIndex(File reportDir) {
- def number = 0
- while (true) {
- def freshIndex = reportDir.toPath().resolve("index.${number++}.html").toFile()
- if (!freshIndex.exists()) {
- return freshIndex
- }
- }
-}
-
-def forEachTestReportAlreadyX(File reportDir, fileName, onTest) {
- def out = new StringBuilder()
- def err = new StringBuilder()
- def proc = "find . -name ${fileName}".execute([], reportDir)
- proc.waitForProcessOutput(out, err)
- def outString = out.toString()
- outString.eachLine {
- // Lines are of the form: ./<class>/<name>/FAILURE
- def clazz = null
- def name = null
- try {
- def trimmed = it.trim()
- def line = trimmed.substring(2)
- def sep = line.indexOf("/")
- clazz = line.substring(0, sep)
- name = line.substring(sep + 1, line.length() - fileName.length() - 1)
- } catch (Exception e) {
- logger.lifecycle("WARNING: failed attempt to read test description from: '${it}'")
- return
- }
- onTest(clazz, desanitizedTestName(name))
- }
- return !outString.trim().isEmpty()
-}
-
-def forEachTestReportAlreadyFailing(File reportDir, onFailureTest) {
- return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.FAILURE.name(), onFailureTest)
-}
-
-def forEachTestReportAlreadyPassing(File reportDir, onSucceededTest) {
- return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.SUCCESS.name(), onSucceededTest)
-}
-
-def forEachTestReportAlreadySkipped(File reportDir, onSucceededTest) {
- return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.SKIPPED.name(), onSucceededTest)
-}
-
-def setUpTestingState(Test task) {
- // Hide all test events from the console, they are written to the report.
- task.testLogging { events = [] }
-
- def branch = project.hasProperty('testing-state-name')
- ? project.getProperty('testing-state-name')
- : getGitBranchName()
- def reportDir = file("${buildDir}/test-state/${branch}")
- def index = reportDir.toPath().resolve("index.html").toFile()
- def resetState = project.hasProperty('reset-testing-state')
- def reportDirExists = reportDir.exists()
- def resuming = !resetState && reportDirExists
-
- def hasFailingTests = false;
- if (resuming) {
- // Test filtering happens before the test execution is initiated so compute it here.
- // If there are still failing tests in the report, include only those.
- hasFailingTests = forEachTestReportAlreadyFailing(reportDir, {
- clazz, name -> task.filter.includeTestsMatching("$clazz.$name")
- })
- // Otherwise exclude all of the test already marked as succeeding.
- if (!hasFailingTests) {
- // Also allow the test to overall succeed if there are no remaining tests that match,
- // which is natural if the state already succeeded in full.
- task.filter.failOnNoMatchingTests = false
- forEachTestReportAlreadyPassing(reportDir, {
- clazz, name -> task.filter.excludeTestsMatching("$clazz.$name")
- })
- forEachTestReportAlreadySkipped(reportDir, {
- clazz, name -> task.filter.excludeTestsMatching("$clazz.$name")
- })
- }
- }
-
- task.beforeSuite { desc ->
- if (!desc.parent) {
- def parentReport = null
- if (resetState && reportDirExists) {
- delete reportDir
- }
- if (resuming) {
- if (index.exists()) {
- parentReport = getFreshTestReportIndex(reportDir)
- index.renameTo(parentReport)
- }
- } else {
- reportDir.mkdirs()
- }
- def runPrefix = resuming ? "Resuming" : "Starting"
- def title = "${runPrefix} @ ${branch}"
- // Print a console link to the test report for easy access.
- println "${runPrefix} test, report written to:"
- println " file://${index}"
- // Print the new index content.
- index << "<html><head><title>${title}</title>"
- index << "<style> * { font-family: monospace; }</style>"
- index << "<meta http-equiv='refresh' content='10' />"
- index << "</head><body><h1>${title}</h1>"
- index << "<p>Run on: ${new Date()}</p>"
- index << "<p>Git branch: ${branch}</p>"
- if (parentReport != null) {
- index << "<p><a href=\"file://${parentReport}\">Previous result index</a></p>"
- }
- index << "<p><a href=\"file://${index}\">Most recent result index</a></p>"
- index << "<p><a href=\"file://${reportDir}\">Test directories</a></p>"
- index << "<h2>Failing tests (refreshing automatically every 10 seconds)</h2><ul>"
- }
- }
-
- task.afterSuite { desc, result ->
- if (!desc.parent) {
- // Update the final test results in the index.
- index << "</ul>"
- if (result.resultType == TestResult.ResultType.SUCCESS) {
- if (hasFailingTests) {
- index << "<h2>Rerun of failed tests now pass!</h2>"
- index << "<h2>Rerun again to continue with outstanding tests!</h2>"
- } else {
- index << "<h2 style=\"background-color:#62D856\">GREEN BAR == YOU ROCK!</h2>"
- }
- } else if (result.resultType == TestResult.ResultType.FAILURE) {
- index << "<h2 style=\"background-color:#6D130A\">Some tests failed: ${result.resultType.name()}</h2><ul>"
- } else {
- index << "<h2>Tests finished: ${result.resultType.name()}</h2><ul>"
- }
- index << "<li>Number of tests: ${result.testCount}"
- index << "<li>Failing tests: ${result.failedTestCount}"
- index << "<li>Successful tests: ${result.successfulTestCount}"
- index << "<li>Skipped tests: ${result.skippedTestCount}"
- index << "</ul></body></html>"
- }
- }
-
- // Events to stdout/err are appended to the files in the test directories.
- task.onOutput { desc, event ->
- withTestResultEntryWriter(reportDir, desc, event.getDestination().name(), true, {
- it.append(event.getMessage())
- })
- }
-
- task.beforeTest { desc ->
- // Remove any stale output files before running the test.
- for (def destType : TestOutputEvent.Destination.values()) {
- def destFile = getTestResultEntryOutputFile(reportDir, desc, destType.name())
- if (destFile.exists()) {
- delete destFile
- }
- }
- }
-
- task.afterTest { desc, result ->
- if (result.getTestCount() != 1) {
- throw new IllegalStateException("Unexpected test with more than one result: ${desc}")
- }
- // Clear any previous result files.
- for (def resultType : TestResult.ResultType.values()) {
- delete getTestResultEntryOutputFile(reportDir, desc, resultType.name())
- }
- // Emit the result type status in a file of the same name: SUCCESS, FAILURE or SKIPPED.
- withTestResultEntryWriter(reportDir, desc, result.getResultType().name(), false, {
- it.append(result.getResultType().name())
- })
- // Emit the test time.
- withTestResultEntryWriter(reportDir, desc, "time", false, {
- it.append("${result.getEndTime() - result.getStartTime()}")
- })
- // For failed tests, update the index and emit stack trace information.
- if (result.resultType == TestResult.ResultType.FAILURE) {
- def title = escapeHtml("${desc.className}.${desc.name}")
- def link = getTestReportEntryURL(reportDir, desc)
- index << "<li><a href=\"${link}\">${title}</a></li>"
- if (!result.exceptions.isEmpty()) {
- printAllStackTracesToFile(
- result.exceptions,
- getTestResultEntryOutputFile(
- reportDir,
- desc,
- "exceptions-raw.txt"))
- filterStackTraces(result)
- printAllStackTracesToFile(
- result.exceptions,
- getTestResultEntryOutputFile(
- reportDir,
- desc,
- "exceptions-filtered.txt"))
- if (shouldRetrace()) {
- withTestResultEntryWriter(reportDir, desc, "exceptions-retraced.txt", false, { writer ->
- result.exceptions.forEach { writer.append(retrace(it)) }
- })
- }
- }
- }
- }
-}
-
-def testTimes = [:]
-def numberOfTestTimesToPrint = 100
-
-test { task ->
-
- dependsOn sourceSets.keepanno.output
- // R8.jar is required for running bootstrap tests.
- dependsOn r8
-
- def useTestingState = project.hasProperty('testing-state')
- if (useTestingState) {
- setUpTestingState(task)
- }
-
- if (project.hasProperty('generate_golden_files_to')) {
- systemProperty 'generate_golden_files_to', project.property('generate_golden_files_to')
- assert project.hasProperty('HEAD_sha1')
- systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
- }
-
- if (project.hasProperty('use_golden_files_in')) {
- systemProperty 'use_golden_files_in', project.property('use_golden_files_in')
- assert project.hasProperty('HEAD_sha1')
- systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
- }
-
- if (project.hasProperty('kotlin_compiler_dev')) {
- systemProperty 'com.android.tools.r8.kotlincompilerdev', '1';
- }
-
- if (project.hasProperty('kotlin_compiler_old')) {
- systemProperty 'com.android.tools.r8.kotlincompilerold', '1';
- }
-
- if (!useTestingState) {
- testLogging.exceptionFormat = 'full'
- if (project.hasProperty('print_test_stdout')) {
- testLogging.showStandardStreams = true
- }
- }
- if (project.hasProperty('dex_vm') && project.property('dex_vm') != 'default') {
- println "NOTE: Running with non default vm: " + project.property('dex_vm')
- systemProperty 'dex_vm', project.property('dex_vm')
- }
-
- // Forward runtime configurations for test parameters.
- if (project.hasProperty('runtimes')) {
- println "NOTE: Running with runtimes: " + project.property('runtimes')
- systemProperty 'runtimes', project.property('runtimes')
- }
-
- if (project.hasProperty('art_profile_rewriting_completeness_check')) {
- String key = 'com.android.tools.r8.artprofilerewritingcompletenesscheck'
- String value = project.property('art_profile_rewriting_completeness_check')
- systemProperty key, value
- }
-
- if (project.hasProperty('slow_tests')) {
- systemProperty 'slow_tests', project.property('slow_tests')
- }
-
-
- if (project.hasProperty('desugar_jdk_json_dir')) {
- systemProperty 'desugar_jdk_json_dir', project.property('desugar_jdk_json_dir')
- }
- if (project.hasProperty('desugar_jdk_libs')) {
- systemProperty 'desugar_jdk_libs', project.property('desugar_jdk_libs')
- }
-
- if (!useTestingState) {
- if (project.hasProperty('print_times') || project.hasProperty('one_line_per_test')) {
- afterTest { desc, result ->
- def executionTime = (result.endTime - result.startTime) / 1000
- testTimes["${desc.name} [${desc.className}]"] = executionTime
- }
- afterSuite { desc, result ->
- // parent is null if all tests are done.
- if (desc.parent == null) {
- def sortedTimes = testTimes.sort({ e1, e2 -> e2.value <=> e1.value })
- sortedTimes.eachWithIndex { key, value, i ->
- println "$key: $value"
- }
- }
- }
- }
-
- if (project.hasProperty('one_line_per_test')) {
- beforeTest { desc ->
- println "Start executing test ${desc.name} [${desc.className}]"
- }
-
- afterTest { desc, result ->
- if (result.resultType == TestResult.ResultType.FAILURE) {
- printStackTrace(result)
- }
- if (project.hasProperty('update_test_timestamp')) {
- file(project.getProperty('update_test_timestamp')).text = new Date().getTime()
- }
- println "Done executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
- }
- } else {
- afterTest { desc, result ->
- if (result.resultType == TestResult.ResultType.FAILURE) {
- printStackTrace(result)
- }
- }
- }
- }
- if (project.hasProperty('no_internal')) {
- exclude "com/android/tools/r8/internal/**"
- }
- if (project.hasProperty('only_internal')) {
- include "com/android/tools/r8/internal/**"
- }
-
- if (project.hasProperty('test_namespace')) {
- include "com/android/tools/r8/" + project.getProperty('test_namespace') + "/**"
- }
-
- if (project.hasProperty('tool') && project.property('tool') == 'd8') {
- // Don't run anything, deprecated
- println "Running with deprecated tool d8, not running any tests"
- include ""
- }
- if (project.hasProperty('no_arttests')) {
- exclude "com/android/tools/r8/art/**"
- }
- if (project.hasProperty('shard_count') ) {
- assert project.hasProperty('shard_number')
- int shard_count = project.getProperty('shard_count') as Integer
- int shard_number = project.getProperty('shard_number') as Integer
- assert shard_count < 65536
- assert shard_number < shard_count
- exclude {
- entry ->
- // Don't leave out directories. Leaving out a directory means all entries below.
- if (entry.file.isDirectory()) {
- return false
- }
- def first4 = entry.getRelativePath().toString().md5().substring(0, 4)
- int hash = Integer.parseInt(first4, 16)
- return hash % shard_count != shard_number
- }
- }
- if (project.hasProperty('test_dir')) {
- systemProperty 'test_dir', project.property('test_dir')
- }
- if (project.hasProperty('command_cache_dir')) {
- systemProperty 'command_cache_dir', project.property('command_cache_dir')
- }
- if (project.hasProperty('command_cache_stats_dir')) {
- systemProperty 'command_cache_stats_dir', project.property('command_cache_stats_dir')
- }
- if (project.hasProperty('r8lib')) {
- dependsOn configureTestForR8Lib
- // R8lib should be used instead of the main output and all the tests in
- // r8 should be mapped and exists in r8LibTestPath.
- classpath = sourceSets.test.runtimeClasspath.filter {
- !it.getAbsolutePath().contains("/build/")
- }
- classpath += files([r8LibPath, r8LibTestPath])
- testClassesDirs = files(r8LibTestPath)
- }
- if (OperatingSystem.current().isLinux()
- || OperatingSystem.current().isMacOsX()
- || OperatingSystem.current().isWindows()) {
- if (OperatingSystem.current().isMacOsX()) {
- logger.lifecycle("WARNING: Testing in only partially supported on Mac OS. " +
- "Art only runs on Linux and tests requiring Art runs in a Docker container, which must be present. " +
- "See tools/docker/README.md for details.")
- }
- if (OperatingSystem.current().isWindows()) {
- logger.lifecycle("WARNING: Testing in only partially supported on Windows. " +
- "Art only runs on Linux and tests requiring Art will be skipped")
- }
- dependsOn downloadDeps
- dependsOn buildExamples
- } else {
- logger.lifecycle("WARNING: Testing in not supported on your platform. Testing is only fully supported on " +
- "Linux and partially supported on Mac OS and Windows. Art does not run on other platforms.")
- }
-}
-
-
-task javadocD8(type: Javadoc) {
- title "D8 API"
- classpath = sourceSets.main.compileClasspath
- source = sourceSets.main.allJava
- include '**/com/android/tools/r8/ArchiveClassFileProvider.java'
- include '**/com/android/tools/r8/ArchiveProgramResourceProvider.java'
- include '**/com/android/tools/r8/BaseCommand.java'
- include '**/com/android/tools/r8/BaseCompilerCommand.java'
- include '**/com/android/tools/r8/ClassFileResourceProvider.java'
- include '**/com/android/tools/r8/CompilationFailedException.java'
- include '**/com/android/tools/r8/CompilationMode.java'
- include '**/com/android/tools/r8/D8.java'
- include '**/com/android/tools/r8/D8Command.java'
- include '**/com/android/tools/r8/DexIndexedConsumer.java'
- include '**/com/android/tools/r8/DexFilePerClassFileConsumer.java'
- include '**/com/android/tools/r8/Diagnostic.java'
- include '**/com/android/tools/r8/DiagnosticsHandler.java'
- include '**/com/android/tools/r8/DirectoryClassFileProvider.java'
- include '**/com/android/tools/r8/OutputMode.java'
- include '**/com/android/tools/r8/ProgramConsumer.java'
- include '**/com/android/tools/r8/ProgramResource.java'
- include '**/com/android/tools/r8/ProgramResourceProvider.java'
- include '**/com/android/tools/r8/Resource.java'
- include '**/com/android/tools/r8/ResourceException.java'
- include '**/com/android/tools/r8/StringConsumer.java'
- include '**/com/android/tools/r8/StringResource.java'
- include '**/com/android/tools/r8/Version.java'
- include '**/com/android/tools/r8/origin/*.java'
-}
-
-task javadocR8(type: Javadoc) {
- title "R8 API"
- classpath = sourceSets.main.compileClasspath
- source = sourceSets.main.allJava
- include '**/com/android/tools/r8/ArchiveClassFileProvider.java'
- include '**/com/android/tools/r8/ArchiveProgramResourceProvider.java'
- include '**/com/android/tools/r8/BaseCommand.java'
- include '**/com/android/tools/r8/BaseCompilerCommand.java'
- include '**/com/android/tools/r8/ClassFileConsumer.java'
- include '**/com/android/tools/r8/ClassFileResourceProvider.java'
- include '**/com/android/tools/r8/CompilationFailedException.java'
- include '**/com/android/tools/r8/CompilationMode.java'
- include '**/com/android/tools/r8/R8.java'
- include '**/com/android/tools/r8/R8Command.java'
- include '**/com/android/tools/r8/DexIndexedConsumer.java'
- include '**/com/android/tools/r8/Diagnostic.java'
- include '**/com/android/tools/r8/DiagnosticsHandler.java'
- include '**/com/android/tools/r8/DirectoryClassFileProvider.java'
- include '**/com/android/tools/r8/OutputMode.java'
- include '**/com/android/tools/r8/ProgramConsumer.java'
- include '**/com/android/tools/r8/ProgramResource.java'
- include '**/com/android/tools/r8/ProgramResourceProvider.java'
- include '**/com/android/tools/r8/Resource.java'
- include '**/com/android/tools/r8/ResourceException.java'
- include '**/com/android/tools/r8/StringConsumer.java'
- include '**/com/android/tools/r8/StringResource.java'
- include '**/com/android/tools/r8/Version.java'
- include '**/com/android/tools/r8/origin/*.java'
-}
-
-task copyMavenDeps(type: Copy) {
- from configurations.compile into "$buildDir/deps"
- from configurations.compileClasspath into "$buildDir/deps"
- from configurations.testCompile into "$buildDir/deps"
-}
-
-task printMavenDeps {
- // Only actually print to stdout when we are updating.
- if (project.hasProperty('updatemavendeps')) {
- for (Configuration config : configurations) {
- if (!config.isCanBeResolved()) {
- continue
- }
- def componentIds = config.incoming.resolutionResult.allDependencies.collect {
- it.selected.id
- }
- def result = dependencies.createArtifactResolutionQuery()
- .forComponents(componentIds)
- .withArtifacts(MavenModule, MavenPomArtifact)
- .execute()
- for (component in result.resolvedComponents) {
- component.getArtifacts(MavenPomArtifact).each {
- println "POM: ${it.file} ${component.id}"
- }
- }
- config.each {
- println "JAR: ${it}"
- }
- }
- }
-}
-
-allprojects {
- tasks.withType(Exec) {
- doFirst {
- println commandLine.join(' ')
- }
- }
-}
diff --git a/settings.gradle b/settings.gradle
deleted file mode 100644
index 969cb9c..0000000
--- a/settings.gradle
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import org.gradle.internal.os.OperatingSystem
-
-rootProject.name = 'r8'
-
-// Bootstrap building by downloading dependencies.
-def dependencies_bucket = "r8-deps"
-def dependencies_sha1_file = "third_party/dependencies.tar.gz.sha1"
-def extension = OperatingSystem.current().isWindows() ? ".bat" : ".py"
-
-def cmd =
- ("download_from_google_storage${extension} --extract"
- + " --bucket ${dependencies_bucket}"
- + " --sha1_file ${dependencies_sha1_file}")
-def process = cmd.execute()
-process.waitFor()
-if (process.exitValue() != 0) {
- throw new GradleException(
- "Bootstrapping dependencies download failed:\n"
- + "STDOUT:\n${process.in.text}\n"
- + "STDERR:\n${process.err.text}")
-}
\ No newline at end of file
