From 8fc0c1d7b0e0ea05f2abb5f4063fc3068a2fdceb Mon Sep 17 00:00:00 2001 From: Vyacheslav Gerasimov Date: Thu, 2 Aug 2018 19:56:16 +0300 Subject: [PATCH] as33: Add AS 3.3 bunchset built with AS 3.3 C4 --- buildSrc/gradle.properties.as33 | 9 + generators/build.gradle.kts.as33 | 53 +++++ .../generators/tests/GenerateTests.kt.as33 | 89 ++++++++- idea/build.gradle.kts.as33 | 182 ++++++++++++++++++ .../KotlinExplicitMovementProvider.kt.as33 | 0 idea/idea-gradle/build.gradle.kts.as33 | 68 +++++++ idea/idea-maven/build.gradle.kts.as33 | 69 +++++++ idea/src/META-INF/android-lint.xml.as33 | 5 + idea/src/META-INF/git4idea.xml.as33 | 4 + idea/src/META-INF/gradle-java.xml.as33 | 80 ++++++++ idea/src/META-INF/plugin.xml | 2 +- idea/src/META-INF/plugin.xml.as33 | 12 +- .../reporter/KotlinReportSubmitter.kt.as33 | 82 ++++++++ .../kotlin/idea/update/verify.kt.as33 | 35 ++++ j2k/build.gradle.kts.as33 | 78 ++++++++ ...avaToKotlinConverterForWebDemoTest.kt.as33 | 134 +++++++++++++ jps-plugin/build.gradle.kts.as33 | 53 +++++ .../AllOpenMavenProjectImportHandler.kt.as33 | 0 .../AndroidModuleInfoProviderImpl.kt.as33 | 78 ++++++++ .../build.gradle.kts.as33 | 2 +- .../src/AbstractMavenImportHandler.kt.as33 | 0 .../NoArgMavenProjectImportHandler.kt.as33 | 0 ...hReceiverMavenProjectImportHandler.kt.as33 | 0 versions.gradle.kts.as33 | 23 +-- 24 files changed, 1037 insertions(+), 21 deletions(-) create mode 100644 buildSrc/gradle.properties.as33 create mode 100644 generators/build.gradle.kts.as33 create mode 100644 idea/build.gradle.kts.as33 create mode 100644 idea/idea-git/src/org/jetbrains/kotlin/git/KotlinExplicitMovementProvider.kt.as33 create mode 100644 idea/idea-gradle/build.gradle.kts.as33 create mode 100644 idea/idea-maven/build.gradle.kts.as33 create mode 100644 idea/src/META-INF/android-lint.xml.as33 create mode 100644 idea/src/META-INF/git4idea.xml.as33 create mode 100644 idea/src/META-INF/gradle-java.xml.as33 create mode 100644 idea/src/org/jetbrains/kotlin/idea/reporter/KotlinReportSubmitter.kt.as33 create mode 100644 idea/src/org/jetbrains/kotlin/idea/update/verify.kt.as33 create mode 100644 j2k/build.gradle.kts.as33 create mode 100644 j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterForWebDemoTest.kt.as33 create mode 100644 jps-plugin/build.gradle.kts.as33 create mode 100644 plugins/allopen/allopen-ide/src/AllOpenMavenProjectImportHandler.kt.as33 create mode 100644 plugins/android-extensions/android-extensions-idea/src/org/jetbrains/kotlin/android/model/impl/AndroidModuleInfoProviderImpl.kt.as33 create mode 100644 plugins/annotation-based-compiler-plugins-ide-support/src/AbstractMavenImportHandler.kt.as33 create mode 100644 plugins/noarg/noarg-ide/src/NoArgMavenProjectImportHandler.kt.as33 create mode 100644 plugins/sam-with-receiver/sam-with-receiver-ide/src/SamWithReceiverMavenProjectImportHandler.kt.as33 diff --git a/buildSrc/gradle.properties.as33 b/buildSrc/gradle.properties.as33 new file mode 100644 index 00000000000..5f8abd5de3c --- /dev/null +++ b/buildSrc/gradle.properties.as33 @@ -0,0 +1,9 @@ +org.gradle.daemon=true +org.gradle.parallel=false +org.gradle.configureondemand=false +org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m + +#buildSrc.kotlin.repo=https://jcenter.bintray.com +#buildSrc.kotlin.version=1.1.50 + +intellijUltimateEnabled=false diff --git a/generators/build.gradle.kts.as33 b/generators/build.gradle.kts.as33 new file mode 100644 index 00000000000..4dcd0f33382 --- /dev/null +++ b/generators/build.gradle.kts.as33 @@ -0,0 +1,53 @@ + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +sourceSets { + "main" { } + "test" { projectDefault() } +} + +val builtinsSourceSet = sourceSets.create("builtins") { + java.srcDir("builtins") +} +val builtinsCompile by configurations + +dependencies { + compile(projectTests(":compiler:cli")) + compile(projectTests(":idea:idea-maven")) + compile(projectTests(":j2k")) + compile(projectTests(":idea:idea-android")) + compile(projectTests(":jps-plugin")) + compile(projectTests(":plugins:android-extensions-compiler")) + compile(projectTests(":plugins:android-extensions-ide")) + compile(projectTests(":plugins:android-extensions-jps")) + compile(projectTests(":kotlin-annotation-processing")) + compile(projectTests(":kotlin-allopen-compiler-plugin")) + compile(projectTests(":kotlin-noarg-compiler-plugin")) + compile(projectTests(":kotlin-sam-with-receiver-compiler-plugin")) + compile(projectTests(":generators:test-generator")) + // testCompileOnly(intellijDep("jps-build-test")) + builtinsCompile("org.jetbrains.kotlin:kotlin-stdlib:$bootstrapKotlinVersion") + testCompileOnly(project(":kotlin-reflect-api")) + testCompile(builtinsSourceSet.output) + testRuntime(intellijDep()) { includeJars("idea_rt") } + testRuntime(projectDist(":kotlin-reflect")) +} + + +projectTest { + workingDir = rootDir +} + +val generateTests by generator("org.jetbrains.kotlin.generators.tests.GenerateTestsKt") + +val generateProtoBuf by generator("org.jetbrains.kotlin.generators.protobuf.GenerateProtoBufKt") +val generateProtoBufCompare by generator("org.jetbrains.kotlin.generators.protobuf.GenerateProtoBufCompare") + +val generateGradleOptions by generator("org.jetbrains.kotlin.generators.arguments.GenerateGradleOptionsKt") + +val generateBuiltins by generator("org.jetbrains.kotlin.generators.builtins.generateBuiltIns.GenerateBuiltInsKt", builtinsSourceSet) + +testsJar() diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as33 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as33 index 82b99a85530..9c9084f12e3 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as33 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as33 @@ -67,7 +67,10 @@ import org.jetbrains.kotlin.idea.conversion.copy.AbstractLiteralKotlinToKotlinCo import org.jetbrains.kotlin.idea.conversion.copy.AbstractLiteralTextToKotlinCopyPasteTest import org.jetbrains.kotlin.idea.conversion.copy.AbstractTextJavaToKotlinCopyPasteConversionTest import org.jetbrains.kotlin.idea.coverage.AbstractKotlinCoverageOutputFilesTest -import org.jetbrains.kotlin.idea.debugger.* +import org.jetbrains.kotlin.idea.debugger.AbstractBeforeExtractFunctionInsertionTest +import org.jetbrains.kotlin.idea.debugger.AbstractKotlinSteppingTest +import org.jetbrains.kotlin.idea.debugger.AbstractPositionManagerTest +import org.jetbrains.kotlin.idea.debugger.AbstractSmartStepIntoTest import org.jetbrains.kotlin.idea.debugger.evaluate.* import org.jetbrains.kotlin.idea.decompiler.navigation.AbstractNavigateToDecompiledLibraryTest import org.jetbrains.kotlin.idea.decompiler.navigation.AbstractNavigateToLibrarySourceTest @@ -625,10 +628,6 @@ fun main(args: Array) { model("debugger/tinyApp/src/evaluate/multipleBreakpoints", testMethod = "doMultipleBreakpointsTest") } - testClass { - model("debugger/fileRanking") - } - testClass { model("stubs", extension = "kt") } @@ -921,7 +920,8 @@ fun main(args: Array) { /* There is no jps in AS testGroup("jps-plugin/jps-tests/test", "jps-plugin/testData") { testClass { - model("incremental/multiModule", extension = null, excludeParentDirs = true) + model("incremental/multiModule/common", extension = null, excludeParentDirs = true) + model("incremental/multiModule/jvm", extension = null, excludeParentDirs = true) model("incremental/pureKotlin", extension = null, recursive = false) model("incremental/withJava", extension = null, excludeParentDirs = true) model("incremental/inlineFunCallSite", extension = null, excludeParentDirs = true) @@ -930,6 +930,10 @@ fun main(args: Array) { actualizeMppJpsIncTestCaseDirs(testDataRoot, "incremental/multiplatform/multiModule") + testClass { + model("incremental/multiModule/common", extension = null, excludeParentDirs = true) + } + testClass { model( "incremental/multiplatform/multiModule", extension = null, excludeParentDirs = true, @@ -1059,6 +1063,79 @@ fun main(args: Array) { } } /* + testGroup("plugins/android-extensions/android-extensions-idea/tests", "plugins/android-extensions/android-extensions-idea/testData") { + testClass { + model("android/completion", recursive = false, extension = null) + } + + testClass { + model("android/goto", recursive = false, extension = null) + } + + testClass { + model("android/rename", recursive = false, extension = null) + } + + testClass { + model("android/renameLayout", recursive = false, extension = null) + } + + testClass { + model("android/findUsages", recursive = false, extension = null) + } + + testClass { + model("android/usageHighlighting", recursive = false, extension = null) + } + + testClass { + model("android/extraction", recursive = false, extension = null) + } + + testClass { + model("android/parcel/checker", excludeParentDirs = true) + } + + testClass { + model("android/parcel/quickfix", pattern = """^(\w+)\.((before\.Main\.\w+)|(test))$""", testMethod = "doTestWithExtraFile") + } + } + + testGroup("idea/idea-android/tests", "idea/testData") { + testClass { + model("configuration/android-gradle", pattern = """(\w+)_before\.gradle$""", testMethod = "doTestAndroidGradle") + model("configuration/android-gsk", pattern = """(\w+)_before\.gradle.kts$""", testMethod = "doTestAndroidGradle") + } + + testClass { + model("android/intention", pattern = "^([\\w\\-_]+)\\.kt$") + } + + testClass { + model("android/resourceIntention", extension = "test", singleClass = true) + } + + testClass { + model("android/quickfix", pattern = """^(\w+)\.((before\.Main\.\w+)|(test))$""", testMethod = "doTestWithExtraFile") + } + + testClass { + model("android/lint", excludeParentDirs = true) + } + + testClass { + model("android/lintQuickfix", pattern = "^([\\w\\-_]+)\\.kt$") + } + + testClass { + model("android/folding") + } + + testClass { + model("android/gutterIcon") + } + } + testGroup("plugins/android-extensions/android-extensions-jps/test", "plugins/android-extensions/android-extensions-jps/testData") { testClass { model("android", recursive = false, extension = null) diff --git a/idea/build.gradle.kts.as33 b/idea/build.gradle.kts.as33 new file mode 100644 index 00000000000..2a14a97153b --- /dev/null +++ b/idea/build.gradle.kts.as33 @@ -0,0 +1,182 @@ +import org.gradle.jvm.tasks.Jar + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testRuntime(intellijDep()) + + compile(projectDist(":kotlin-stdlib-jre8")) + compileOnly(project(":kotlin-reflect-api")) + compile(project(":core:descriptors")) + compile(project(":core:descriptors.jvm")) + compile(project(":compiler:backend")) + compile(project(":compiler:cli-common")) + compile(project(":compiler:frontend")) + compile(project(":compiler:frontend.java")) + compile(project(":compiler:frontend.script")) + compile(project(":js:js.frontend")) + compile(project(":js:js.serializer")) + compile(project(":compiler:light-classes")) + compile(project(":compiler:util")) + compile(project(":kotlin-build-common")) + compile(project(":compiler:daemon-common")) + compile(projectRuntimeJar(":kotlin-daemon-client")) + compile(project(":kotlin-compiler-runner")) { isTransitive = false } + compile(project(":compiler:plugin-api")) + compile(project(":eval4j")) + compile(project(":j2k")) + compile(project(":idea:formatter")) + compile(project(":idea:idea-core")) + compile(project(":idea:ide-common")) + compile(project(":idea:idea-jps-common")) + compile(project(":idea:kotlin-gradle-tooling")) + compile(project(":plugins:uast-kotlin")) + compile(project(":plugins:uast-kotlin-idea")) + compile(project(":kotlin-script-util")) { isTransitive = false } + + compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false } + compile(commonDep("org.jetbrains", "markdown")) + + compileOnly(project(":kotlin-daemon-client")) + + compileOnly(intellijDep()) + compileOnly(commonDep("com.google.code.findbugs", "jsr305")) + compileOnly(intellijPluginDep("IntelliLang")) + compileOnly(intellijPluginDep("copyright")) + compileOnly(intellijPluginDep("properties")) + compileOnly(intellijPluginDep("java-i18n")) + + testCompile(project(":kotlin-test:kotlin-test-junit")) + testCompile(projectTests(":compiler:tests-common")) + testCompile(projectTests(":idea:idea-test-framework")) { isTransitive = false } + testCompile(project(":idea:idea-jvm")) { isTransitive = false } + testCompile(project(":idea:idea-gradle")) { isTransitive = false } + testCompile(project(":idea:idea-maven")) { isTransitive = false } + testCompile(commonDep("junit:junit")) + + testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false } + testRuntime(projectDist(":kotlin-reflect")) + testRuntime(projectDist(":kotlin-preloader")) + + testCompile(project(":kotlin-sam-with-receiver-compiler-plugin")) { isTransitive = false } + + testRuntime(project(":plugins:android-extensions-compiler")) + testRuntime(project(":plugins:android-extensions-ide")) { isTransitive = false } + testRuntime(project(":allopen-ide-plugin")) { isTransitive = false } + testRuntime(project(":kotlin-allopen-compiler-plugin")) + testRuntime(project(":noarg-ide-plugin")) { isTransitive = false } + testRuntime(project(":kotlin-noarg-compiler-plugin")) + testRuntime(project(":plugins:annotation-based-compiler-plugins-ide-support")) { isTransitive = false } + testRuntime(project(":kotlin-scripting-idea")) { isTransitive = false } + testRuntime(project(":kotlin-scripting-compiler")) + testRuntime(project(":sam-with-receiver-ide-plugin")) { isTransitive = false } + testRuntime(project(":idea:idea-android")) { isTransitive = false } + testRuntime(project(":plugins:lint")) { isTransitive = false } + testRuntime(project(":plugins:uast-kotlin")) + + (rootProject.extra["compilerModules"] as Array).forEach { + testRuntime(project(it)) + } + + testCompile(intellijPluginDep("IntelliLang")) + testCompile(intellijPluginDep("copyright")) + testCompile(intellijPluginDep("properties")) + testCompile(intellijPluginDep("java-i18n")) + testCompileOnly(intellijDep()) + testCompileOnly(commonDep("com.google.code.findbugs", "jsr305")) + testCompileOnly(intellijPluginDep("gradle")) + testCompileOnly(intellijPluginDep("Groovy")) + //testCompileOnly(intellijPluginDep("maven")) + + testRuntime(intellijPluginDep("junit")) + testRuntime(intellijPluginDep("gradle")) + testRuntime(intellijPluginDep("Groovy")) + testRuntime(intellijPluginDep("coverage")) + //testRuntime(intellijPluginDep("maven")) + testRuntime(intellijPluginDep("android")) + testRuntime(intellijPluginDep("smali")) + testRuntime(intellijPluginDep("testng")) +} + +sourceSets { + "main" { + projectDefault() + java.srcDirs( + "idea-completion/src", + "idea-live-templates/src", + "idea-repl/src" + ) + resources.srcDirs("idea-repl/src").apply { include("META-INF/**") } + } + "test" { + projectDefault() + java.srcDirs( + "idea-completion/tests", + "idea-live-templates/tests" + ) + } + +} + +val performanceTestCompile by configurations.creating { + extendsFrom(configurations["testCompile"]) +} + +val performanceTestRuntime by configurations.creating { + extendsFrom(configurations["testRuntime"]) +} + +val performanceTest by run { + sourceSets.creating { + compileClasspath += sourceSets["test"].output + compileClasspath += sourceSets["main"].output + runtimeClasspath += sourceSets["test"].output + runtimeClasspath += sourceSets["main"].output + java.srcDirs("performanceTests") + } +} + +projectTest { + dependsOn(":dist") + workingDir = rootDir +} + + +projectTest(taskName = "performanceTest") { + dependsOn(":dist") + dependsOn(performanceTest.output) + testClassesDirs = performanceTest.output.classesDirs + classpath = performanceTest.runtimeClasspath + workingDir = rootDir + + jvmArgs?.removeAll { it.startsWith("-Xmx") } + + maxHeapSize = "3g" + jvmArgs("-XX:SoftRefLRUPolicyMSPerMB=50") + jvmArgs( + "-XX:ReservedCodeCacheSize=240m", + "-XX:+UseCompressedOops", + "-XX:+UseConcMarkSweepGC" + ) + jvmArgs("-XX:+UnlockCommercialFeatures", "-XX:+FlightRecorder") + + if (hasProperty("perf.flight.recorder.override")) { + jvmArgs(property("perf.flight.recorder.override")) + } else { + val settings = if (hasProperty("perf.flight.recorder.settings")) ",settings=${property("perf.flight.recorder.settings")}" else "" + jvmArgs("-XX:StartFlightRecording=delay=15m,duration=5h,filename=perf.jfr$settings") + } + + doFirst { + systemProperty("idea.home.path", intellijRootDir().canonicalPath) + } +} + +testsJar {} + +classesDirsArtifact() +configureInstrumentation() + diff --git a/idea/idea-git/src/org/jetbrains/kotlin/git/KotlinExplicitMovementProvider.kt.as33 b/idea/idea-git/src/org/jetbrains/kotlin/git/KotlinExplicitMovementProvider.kt.as33 new file mode 100644 index 00000000000..e69de29bb2d diff --git a/idea/idea-gradle/build.gradle.kts.as33 b/idea/idea-gradle/build.gradle.kts.as33 new file mode 100644 index 00000000000..a3ecc33d3eb --- /dev/null +++ b/idea/idea-gradle/build.gradle.kts.as33 @@ -0,0 +1,68 @@ +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testRuntime(intellijDep()) + + compileOnly(project(":idea")) + compileOnly(project(":idea:idea-jvm")) + compile(project(":idea:kotlin-gradle-tooling")) + + compile(project(":compiler:frontend")) + compile(project(":compiler:frontend.java")) + compile(project(":compiler:frontend.script")) + + compile(project(":js:js.frontend")) + + compileOnly(intellijDep()) + compileOnly(intellijPluginDep("gradle")) + compileOnly(intellijPluginDep("Groovy")) + compileOnly(intellijPluginDep("junit")) + + testCompile(projectTests(":idea")) + testCompile(projectTests(":idea:idea-test-framework")) + + testCompile(intellijPluginDep("gradle")) + testCompileOnly(intellijPluginDep("Groovy")) + testCompileOnly(intellijDep()) + + testRuntime(projectDist(":kotlin-reflect")) + testRuntime(project(":idea:idea-jvm")) + testRuntime(project(":idea:idea-android")) + testRuntime(project(":plugins:kapt3-idea")) + testRuntime(project(":plugins:android-extensions-ide")) + testRuntime(project(":plugins:lint")) + testRuntime(project(":sam-with-receiver-ide-plugin")) + testRuntime(project(":allopen-ide-plugin")) + testRuntime(project(":noarg-ide-plugin")) + testRuntime(project(":kotlin-scripting-idea")) + // TODO: the order of the plugins matters here, consider avoiding order-dependency + testRuntime(intellijPluginDep("junit")) + testRuntime(intellijPluginDep("testng")) + testRuntime(intellijPluginDep("properties")) + testRuntime(intellijPluginDep("gradle")) + testRuntime(intellijPluginDep("Groovy")) + testRuntime(intellijPluginDep("coverage")) + //testRuntime(intellijPluginDep("maven")) + testRuntime(intellijPluginDep("android")) + testRuntime(intellijPluginDep("smali")) +} + +sourceSets { + "main" { + projectDefault() + resources.srcDir("res").apply { include("**") } + } + "test" { projectDefault() } +} + +testsJar() + +projectTest { + workingDir = rootDir + useAndroidSdk() +} + +configureInstrumentation() diff --git a/idea/idea-maven/build.gradle.kts.as33 b/idea/idea-maven/build.gradle.kts.as33 new file mode 100644 index 00000000000..22b187f1d0b --- /dev/null +++ b/idea/idea-maven/build.gradle.kts.as33 @@ -0,0 +1,69 @@ + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + compile(project(":core:util.runtime")) + compile(project(":compiler:frontend")) + compile(project(":compiler:frontend.java")) + compile(project(":compiler:util")) + compile(project(":compiler:cli-common")) + compile(project(":kotlin-build-common")) + + compile(project(":js:js.frontend")) + + compile(project(":idea")) + compile(project(":idea:idea-jvm")) + compile(project(":idea:idea-jps-common")) + + compileOnly(intellijDep()) + excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) } + + testCompile(projectTests(":idea")) + testCompile(projectTests(":compiler:tests-common")) + testCompile(projectTests(":idea:idea-test-framework")) + + testCompileOnly(intellijDep()) + //testCompileOnly(intellijPluginDep("maven")) + + testRuntime(projectDist(":kotlin-reflect")) + testRuntime(project(":idea:idea-jvm")) + testRuntime(project(":idea:idea-android")) + testRuntime(project(":plugins:android-extensions-ide")) + testRuntime(project(":plugins:lint")) + testRuntime(project(":sam-with-receiver-ide-plugin")) + testRuntime(project(":allopen-ide-plugin")) + testRuntime(project(":noarg-ide-plugin")) + testRuntime(project(":kotlin-scripting-idea")) + + testRuntime(intellijDep()) + // TODO: the order of the plugins matters here, consider avoiding order-dependency + testRuntime(intellijPluginDep("junit")) + testRuntime(intellijPluginDep("testng")) + testRuntime(intellijPluginDep("properties")) + testRuntime(intellijPluginDep("gradle")) + testRuntime(intellijPluginDep("Groovy")) + testRuntime(intellijPluginDep("coverage")) + //testRuntime(intellijPluginDep("maven")) + testRuntime(intellijPluginDep("android")) + testRuntime(intellijPluginDep("smali")) +} + +sourceSets { + "main" { /*projectDefault()*/ } + "test" { /*projectDefault()*/ } +} + +testsJar() + +projectTest { + workingDir = rootDir +} + +runtimeJar { + archiveName = "maven-ide.jar" +} + +ideaPlugin() \ No newline at end of file diff --git a/idea/src/META-INF/android-lint.xml.as33 b/idea/src/META-INF/android-lint.xml.as33 new file mode 100644 index 00000000000..5a029687008 --- /dev/null +++ b/idea/src/META-INF/android-lint.xml.as33 @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/idea/src/META-INF/git4idea.xml.as33 b/idea/src/META-INF/git4idea.xml.as33 new file mode 100644 index 00000000000..1bb24d148a3 --- /dev/null +++ b/idea/src/META-INF/git4idea.xml.as33 @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/idea/src/META-INF/gradle-java.xml.as33 b/idea/src/META-INF/gradle-java.xml.as33 new file mode 100644 index 00000000000..2b0767294f3 --- /dev/null +++ b/idea/src/META-INF/gradle-java.xml.as33 @@ -0,0 +1,80 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index f7dceb6749f..8a852cfa69b 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -2920,7 +2920,7 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio. level="INFORMATION" language="kotlin" /> - + @snapshot@ JetBrains - + com.intellij.modules.platform com.intellij.modules.androidstudio @@ -23,12 +23,12 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio. JUnit org.jetbrains.plugins.gradle + org.jetbrains.plugins.gradle.java org.jetbrains.idea.maven TestNG-J com.intellij.copyright Coverage com.intellij.java-i18n - org.intellij.intelliLang org.jetbrains.java.decompiler Git4Idea @@ -37,6 +37,8 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio. com.intellij.modules.java JavaScriptDebugger + com.intellij.copyright + org.intellij.intelliLang @@ -854,6 +856,8 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio. + + org.jetbrains.kotlin.idea.intentions.FoldInitializerAndIfToElvisIntention Kotlin @@ -3034,4 +3038,8 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio. + + + + diff --git a/idea/src/org/jetbrains/kotlin/idea/reporter/KotlinReportSubmitter.kt.as33 b/idea/src/org/jetbrains/kotlin/idea/reporter/KotlinReportSubmitter.kt.as33 new file mode 100644 index 00000000000..9572b8bca94 --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/reporter/KotlinReportSubmitter.kt.as33 @@ -0,0 +1,82 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * 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 org.jetbrains.kotlin.idea.reporter + +import com.intellij.diagnostic.ITNReporter +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.diagnostic.IdeaLoggingEvent +import com.intellij.openapi.diagnostic.SubmittedReportInfo +import com.intellij.openapi.ui.Messages +import com.intellij.util.Consumer +import org.jetbrains.kotlin.idea.KotlinPluginUpdater +import org.jetbrains.kotlin.idea.KotlinPluginUtil +import org.jetbrains.kotlin.idea.PluginUpdateStatus +import java.awt.Component + +/** + * We need to wrap ITNReporter for force showing or errors from kotlin plugin even from released version of IDEA. + */ +class KotlinReportSubmitter : ITNReporter() { + private var hasUpdate = false + private var hasLatestVersion = false + + override fun showErrorInRelease(event: IdeaLoggingEvent): Boolean { + val notificationEnabled = "disabled" != System.getProperty("kotlin.fatal.error.notification", "enabled") + return notificationEnabled && (!hasUpdate || ApplicationManager.getApplication().isInternal) + } + + override fun submit(events: Array, additionalInfo: String?, parentComponent: Component?, consumer: Consumer): Boolean { + if (hasUpdate) { + if (ApplicationManager.getApplication().isInternal) { + return super.submit(events, additionalInfo, parentComponent, consumer) + } + return true + } + + if (hasLatestVersion) { + return super.submit(events, additionalInfo, parentComponent, consumer) + } + + KotlinPluginUpdater.getInstance().runUpdateCheck { status -> + if (status is PluginUpdateStatus.Update) { + hasUpdate = true + if (parentComponent != null) { + + if (ApplicationManager.getApplication().isInternal) { + super.submit(events, additionalInfo, parentComponent, consumer) + } + + val rc = Messages.showDialog(parentComponent, + "You're running Kotlin plugin version ${KotlinPluginUtil.getPluginVersion()}, " + + "while the latest version is ${status.pluginDescriptor.version}", + "Update Kotlin Plugin", + arrayOf("Update", "Ignore"), + 0, Messages.getInformationIcon()) + if (rc == 0) { + KotlinPluginUpdater.getInstance().installPluginUpdate(status) + } + } + } + else { + hasLatestVersion = true + super.submit(events, additionalInfo, parentComponent, consumer) + } + false + } + return true + } +} diff --git a/idea/src/org/jetbrains/kotlin/idea/update/verify.kt.as33 b/idea/src/org/jetbrains/kotlin/idea/update/verify.kt.as33 new file mode 100644 index 00000000000..7899e34573b --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/update/verify.kt.as33 @@ -0,0 +1,35 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.update + +import com.intellij.ide.plugins.IdeaPluginDescriptor +import com.intellij.openapi.util.registry.Registry +import org.jetbrains.kotlin.idea.PluginUpdateStatus + +// Do an additional verification with PluginUpdateVerifier. Enabled only in AS 3.2+ +fun verify(updateStatus: PluginUpdateStatus.Update): PluginUpdateStatus { + @Suppress("InvalidBundleOrProperty") + val pluginVerifierEnabled = Registry.`is`("kotlin.plugin.update.verifier.enabled", true) + if (!pluginVerifierEnabled) { + return updateStatus + } + + val pluginDescriptor: IdeaPluginDescriptor = updateStatus.pluginDescriptor + val pluginVerifiers = PluginUpdateVerifier.EP_NAME.extensions + + for (pluginVerifier in pluginVerifiers) { + val verifyResult = pluginVerifier.verify(pluginDescriptor) ?: continue + if (!verifyResult.verified) { + return PluginUpdateStatus.Unverified( + pluginVerifier.verifierName, + verifyResult.declineMessage, + updateStatus + ) + } + } + + return updateStatus +} \ No newline at end of file diff --git a/j2k/build.gradle.kts.as33 b/j2k/build.gradle.kts.as33 new file mode 100644 index 00000000000..8f36b6d55bb --- /dev/null +++ b/j2k/build.gradle.kts.as33 @@ -0,0 +1,78 @@ + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testRuntime(intellijDep()) + + compile(projectDist(":kotlin-stdlib")) + compile(project(":compiler:frontend")) + compile(project(":compiler:frontend.java")) + compile(project(":compiler:light-classes")) + compile(project(":compiler:util")) + compileOnly(intellijCoreDep()) { includeJars("intellij-core") } + + testCompile(project(":idea")) + testCompile(projectTests(":idea:idea-test-framework")) + testCompile(project(":compiler:light-classes")) + testCompile(projectDist(":kotlin-test:kotlin-test-junit")) + testCompile(commonDep("junit:junit")) + testCompileOnly(intellijDep()) { includeJars("platform-api", "platform-impl") } + + testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false } + testRuntime(project(":idea:idea-jvm")) + testRuntime(project(":idea:idea-android")) + testRuntime(project(":plugins:android-extensions-ide")) + testRuntime(project(":sam-with-receiver-ide-plugin")) + testRuntime(project(":allopen-ide-plugin")) + testRuntime(project(":noarg-ide-plugin")) + testRuntime(project(":kotlin-scripting-idea")) + testRuntime(intellijPluginDep("properties")) + testRuntime(intellijPluginDep("gradle")) + testRuntime(intellijPluginDep("Groovy")) + testRuntime(intellijPluginDep("coverage")) + //testRuntime(intellijPluginDep("maven")) + testRuntime(intellijPluginDep("android")) + testRuntime(intellijPluginDep("smali")) + testRuntime(intellijPluginDep("junit")) + testRuntime(intellijPluginDep("testng")) + testRuntime(intellijPluginDep("IntelliLang")) + testRuntime(intellijPluginDep("testng")) + testRuntime(intellijPluginDep("copyright")) + testRuntime(intellijPluginDep("properties")) + testRuntime(intellijPluginDep("java-i18n")) + testRuntime(intellijPluginDep("java-decompiler")) +} + +sourceSets { + "main" { projectDefault() } + "test" { projectDefault() } +} + +projectTest { + dependsOn(":dist") + workingDir = rootDir +} + +testsJar() + + +val testForWebDemo by task { + include("**/*JavaToKotlinConverterForWebDemoTestGenerated*") + classpath = testSourceSet.runtimeClasspath + workingDir = rootDir +} +val cleanTestForWebDemo by tasks + +val test: Test by tasks +test.apply { + exclude("**/*JavaToKotlinConverterForWebDemoTestGenerated*") + dependsOn(testForWebDemo) +} + +val cleanTest by tasks +cleanTest.dependsOn(cleanTestForWebDemo) + +ideaPlugin() diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterForWebDemoTest.kt.as33 b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterForWebDemoTest.kt.as33 new file mode 100644 index 00000000000..361e62b09c5 --- /dev/null +++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterForWebDemoTest.kt.as33 @@ -0,0 +1,134 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * 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 org.jetbrains.kotlin.j2k + +import com.intellij.codeInsight.ContainerProvider +import com.intellij.codeInsight.NullableNotNullManager +import com.intellij.codeInsight.runner.JavaMainMethodProvider +import com.intellij.core.CoreApplicationEnvironment +import com.intellij.core.JavaCoreApplicationEnvironment +import com.intellij.core.JavaCoreProjectEnvironment +import com.intellij.lang.MetaLanguage +import com.intellij.lang.jvm.facade.JvmElementProvider +import com.intellij.openapi.extensions.Extensions +import com.intellij.openapi.extensions.ExtensionsArea +import com.intellij.openapi.fileTypes.FileTypeExtensionPoint +import com.intellij.openapi.util.Disposer +import com.intellij.openapi.util.io.FileUtil +import com.intellij.psi.* +import com.intellij.psi.augment.PsiAugmentProvider +import com.intellij.psi.augment.TypeAnnotationModifier +import com.intellij.psi.compiled.ClassFileDecompilers +import com.intellij.psi.impl.JavaClassSupersImpl +import com.intellij.psi.impl.PsiTreeChangePreprocessor +import com.intellij.psi.meta.MetaDataContributor +import com.intellij.psi.stubs.BinaryFileStubBuilders +import com.intellij.psi.util.JavaClassSupers +import junit.framework.TestCase +import org.jetbrains.kotlin.utils.PathUtil +import java.io.File +import java.net.URLClassLoader + +abstract class AbstractJavaToKotlinConverterForWebDemoTest : TestCase() { + val DISPOSABLE = Disposer.newDisposable() + + fun doTest(javaPath: String) { + try { + val fileContents = FileUtil.loadFile(File(javaPath), true) + val javaCoreEnvironment: JavaCoreProjectEnvironment = setUpJavaCoreEnvironment() + translateToKotlin(fileContents, javaCoreEnvironment.project) + } + finally { + Disposer.dispose(DISPOSABLE) + } + } + + fun setUpJavaCoreEnvironment(): JavaCoreProjectEnvironment { + Extensions.cleanRootArea(DISPOSABLE) + val area = Extensions.getRootArea() + + registerExtensionPoints(area) + + val applicationEnvironment = JavaCoreApplicationEnvironment(DISPOSABLE) + val javaCoreEnvironment = object : JavaCoreProjectEnvironment(DISPOSABLE, applicationEnvironment) { + override fun preregisterServices() { + val projectArea = Extensions.getArea(project) + CoreApplicationEnvironment.registerExtensionPoint(projectArea, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java) + CoreApplicationEnvironment.registerExtensionPoint(projectArea, PsiElementFinder.EP_NAME, PsiElementFinder::class.java) + CoreApplicationEnvironment.registerExtensionPoint(projectArea, JvmElementProvider.EP_NAME, JvmElementProvider::class.java) + } + } + + javaCoreEnvironment.project.registerService(NullableNotNullManager::class.java, object : NullableNotNullManager(javaCoreEnvironment.project) { + override fun isNullable(owner: PsiModifierListOwner, checkBases: Boolean) = !isNotNull(owner, checkBases) + override fun isNotNull(owner: PsiModifierListOwner, checkBases: Boolean) = true + override fun hasHardcodedContracts(element: PsiElement): Boolean = false + override fun getNullables() = emptyList() + override fun setNullables(vararg p0: String) = Unit + override fun getNotNulls() = emptyList() + override fun setNotNulls(vararg p0: String) = Unit + override fun getDefaultNullable() = "" + override fun setDefaultNullable(defaultNullable: String) = Unit + override fun getDefaultNotNull() = "" + override fun setDefaultNotNull(p0: String) = Unit + override fun getPredefinedNotNulls() = emptyList() + }) + + applicationEnvironment.application.registerService(JavaClassSupers::class.java, JavaClassSupersImpl::class.java) + + for (root in PathUtil.getJdkClassesRootsFromCurrentJre()) { + javaCoreEnvironment.addJarToClassPath(root) + } + val annotations: File? = findAnnotations() + if (annotations != null && annotations.exists()) { + javaCoreEnvironment.addJarToClassPath(annotations) + } + return javaCoreEnvironment + } + + private fun registerExtensionPoints(area: ExtensionsArea) { + CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider::class.java) + + CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider::class.java) + + CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler::class.java) + + CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, JavaModuleSystem.EP_NAME, JavaModuleSystem::class.java) + } + + fun findAnnotations(): File? { + var classLoader = JavaToKotlinTranslator::class.java.classLoader + while (classLoader != null) { + val loader = classLoader + if (loader is URLClassLoader) { + for (url in loader.urLs) { + if ("file" == url.protocol && url.file!!.endsWith("/annotations.jar")) { + return File(url.file!!) + } + } + } + classLoader = classLoader.parent + } + return null + } +} diff --git a/jps-plugin/build.gradle.kts.as33 b/jps-plugin/build.gradle.kts.as33 new file mode 100644 index 00000000000..314de763987 --- /dev/null +++ b/jps-plugin/build.gradle.kts.as33 @@ -0,0 +1,53 @@ +plugins { + kotlin("jvm") + id("jps-compatible") +} + +val compilerModules: Array by rootProject.extra + +dependencies { + compile(project(":kotlin-build-common")) + compile(project(":core:descriptors")) + compile(project(":core:descriptors.jvm")) + compile(project(":kotlin-compiler-runner")) + compile(project(":compiler:daemon-common")) + compile(projectRuntimeJar(":kotlin-daemon-client")) + compile(project(":compiler:frontend.java")) + compile(project(":js:js.frontend")) + compile(projectRuntimeJar(":kotlin-preloader")) + compile(project(":idea:idea-jps-common")) + compileOnly(group = "org.jetbrains", name = "annotations", version = "13.0") + compileOnly(intellijDep()) { includeJars("jdom", "trove4j", "jps-model", "openapi", "platform-api", "util", "asm-all") } + compileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") } + testCompileOnly(project(":kotlin-reflect-api")) + testCompile(project(":compiler:incremental-compilation-impl")) + testCompile(projectTests(":compiler:tests-common")) + testCompile(projectTests(":compiler:incremental-compilation-impl")) + testCompile(commonDep("junit:junit")) + testCompile(projectDist(":kotlin-test:kotlin-test-jvm")) + testCompile(projectTests(":kotlin-build-common")) + testCompileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") } + testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "platform-api", "log4j") } + testCompile(intellijDep("jps-build-test")) + compilerModules.forEach { + testRuntime(project(it)) + } + testRuntime(intellijDep()) + testRuntime(projectDist(":kotlin-reflect")) +} + +sourceSets { + "main" { projectDefault() } + "test" { + /*java.srcDirs("jps-tests/test" + /*, "kannotator-jps-plugin-test/test"*/ // Obsolete + )*/ + } +} + +projectTest { + dependsOn(":kotlin-compiler:dist") + workingDir = rootDir +} + +testsJar {} diff --git a/plugins/allopen/allopen-ide/src/AllOpenMavenProjectImportHandler.kt.as33 b/plugins/allopen/allopen-ide/src/AllOpenMavenProjectImportHandler.kt.as33 new file mode 100644 index 00000000000..e69de29bb2d diff --git a/plugins/android-extensions/android-extensions-idea/src/org/jetbrains/kotlin/android/model/impl/AndroidModuleInfoProviderImpl.kt.as33 b/plugins/android-extensions/android-extensions-idea/src/org/jetbrains/kotlin/android/model/impl/AndroidModuleInfoProviderImpl.kt.as33 new file mode 100644 index 00000000000..7e734004783 --- /dev/null +++ b/plugins/android-extensions/android-extensions-idea/src/org/jetbrains/kotlin/android/model/impl/AndroidModuleInfoProviderImpl.kt.as33 @@ -0,0 +1,78 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.android.model.impl + +import com.android.builder.model.SourceProvider +import com.android.tools.idea.gradle.project.GradleProjectInfo +import com.android.tools.idea.gradle.project.model.AndroidModuleModel +import com.android.tools.idea.res.ResourceRepositoryManager +import com.intellij.openapi.module.Module +import com.intellij.openapi.vfs.VirtualFile +import org.jetbrains.android.facet.AndroidFacet +import org.jetbrains.kotlin.android.model.AndroidModuleInfoProvider +import java.io.File + +class AndroidModuleInfoProviderImpl(override val module: Module) : AndroidModuleInfoProvider { + private val androidFacet: AndroidFacet? + get() = AndroidFacet.getInstance(module) + + private val androidModuleModel: AndroidModuleModel? + get() = AndroidModuleModel.get(module) + + override fun isAndroidModule() = androidFacet != null + override fun isGradleModule() = GradleProjectInfo.getInstance(module.project).isBuildWithGradle + + override fun getAllResourceDirectories(): List { + return androidFacet?.allResourceDirectories ?: emptyList() + } + + override fun getApplicationPackage() = androidFacet?.manifest?.`package`?.toString() + + override fun getMainSourceProvider(): AndroidModuleInfoProvider.SourceProviderMirror? { + return androidFacet?.mainSourceProvider?.let(::SourceProviderMirrorImpl) + } + + override fun getApplicationResourceDirectories(createIfNecessary: Boolean): Collection { + return ResourceRepositoryManager.getOrCreateInstance(module)?.getAppResources(createIfNecessary)?.resourceDirs ?: emptyList() + } + + override fun getAllSourceProviders(): List { + val androidModuleModel = this.androidModuleModel ?: return emptyList() + return androidModuleModel.allSourceProviders.map(::SourceProviderMirrorImpl) + } + + override fun getActiveSourceProviders(): List { + val androidModuleModel = this.androidModuleModel ?: return emptyList() + return androidModuleModel.activeSourceProviders.map(::SourceProviderMirrorImpl) + } + + override fun getFlavorSourceProviders(): List { + val androidModuleModel = this.androidModuleModel ?: return emptyList() + + val getFlavorSourceProvidersMethod = try { + AndroidFacet::class.java.getMethod("getFlavorSourceProviders") + } catch (e: NoSuchMethodException) { + null + } + + return if (getFlavorSourceProvidersMethod != null) { + @Suppress("UNCHECKED_CAST") + val sourceProviders = getFlavorSourceProvidersMethod.invoke(androidFacet) as? List + sourceProviders?.map(::SourceProviderMirrorImpl) ?: emptyList() + } else { + androidModuleModel.flavorSourceProviders.map(::SourceProviderMirrorImpl) + } + } + + private class SourceProviderMirrorImpl(val sourceProvider: SourceProvider) : + AndroidModuleInfoProvider.SourceProviderMirror { + override val name: String + get() = sourceProvider.name + + override val resDirectories: Collection + get() = sourceProvider.resDirectories + } +} \ No newline at end of file diff --git a/plugins/android-extensions/android-extensions-jps/build.gradle.kts.as33 b/plugins/android-extensions/android-extensions-jps/build.gradle.kts.as33 index ee06b927879..f6e75842e75 100644 --- a/plugins/android-extensions/android-extensions-jps/build.gradle.kts.as33 +++ b/plugins/android-extensions/android-extensions-jps/build.gradle.kts.as33 @@ -10,7 +10,7 @@ dependencies { compile(project(":compiler:util")) compile(project(":jps-plugin")) compile(project(":plugins:android-extensions-compiler")) - compileOnly(intellijDep()) { includeJars("openapi", "jps-builders", "jps-model", "jdom") } + compileOnly(intellijDep()) { includeJars("openapi", "platform-api", "jps-builders", "jps-model", "jdom") } compileOnly(intellijPluginDep("android")) { includeJars("jps/android-jps-plugin") } compile(intellijPluginDep("android")) { includeJars("jps/android-jps-plugin") } diff --git a/plugins/annotation-based-compiler-plugins-ide-support/src/AbstractMavenImportHandler.kt.as33 b/plugins/annotation-based-compiler-plugins-ide-support/src/AbstractMavenImportHandler.kt.as33 new file mode 100644 index 00000000000..e69de29bb2d diff --git a/plugins/noarg/noarg-ide/src/NoArgMavenProjectImportHandler.kt.as33 b/plugins/noarg/noarg-ide/src/NoArgMavenProjectImportHandler.kt.as33 new file mode 100644 index 00000000000..e69de29bb2d diff --git a/plugins/sam-with-receiver/sam-with-receiver-ide/src/SamWithReceiverMavenProjectImportHandler.kt.as33 b/plugins/sam-with-receiver/sam-with-receiver-ide/src/SamWithReceiverMavenProjectImportHandler.kt.as33 new file mode 100644 index 00000000000..e69de29bb2d diff --git a/versions.gradle.kts.as33 b/versions.gradle.kts.as33 index 194e588d060..ab909f4d5a8 100644 --- a/versions.gradle.kts.as33 +++ b/versions.gradle.kts.as33 @@ -1,9 +1,8 @@ - -extra["versions.intellijSdk"] = "181.5281.24" +extra["versions.intellijSdk"] = "182.2371.4" extra["versions.androidBuildTools"] = "r23.0.1" -extra["versions.idea.NodeJS"] = "181.2784.17" -extra["versions.androidStudioRelease"] = "3.3.0.2" -extra["versions.androidStudioBuild"] = "181.4884283" +extra["versions.idea.NodeJS"] = "181.3494.12" +extra["versions.androidStudioRelease"] = "3.3.0.3" +extra["versions.androidStudioBuild"] = "182.4902073" val gradleJars = listOf( "gradle-api", @@ -31,7 +30,7 @@ val platform = androidStudioVersion?.let { "AS$it" } ?: platformBaseVersion when (platform) { "182" -> { extra["versions.jar.guava"] = "23.6-jre" - extra["versions.jar.groovy-all"] = "2.4.12" + extra["versions.jar.groovy-all"] = "2.4.15" extra["versions.jar.lombok-ast"] = "0.2.3" extra["versions.jar.swingx-core"] = "1.6.2-2" extra["versions.jar.kxml2"] = "2.3.0" @@ -118,18 +117,20 @@ when (platform) { extra["ignore.jar.lombok-ast"] = true } "AS33" -> { - extra["versions.jar.guava"] = "21.0" - extra["versions.jar.groovy-all"] = "2.4.12" - extra["versions.jar.swingx-core"] = "1.6.2" + extra["versions.jar.guava"] = "23.6-jre" + extra["versions.jar.groovy-all"] = "2.4.15" + extra["versions.jar.lombok-ast"] = "0.2.3" + extra["versions.jar.swingx-core"] = "1.6.2-2" extra["versions.jar.kxml2"] = "2.3.0" extra["versions.jar.streamex"] = "0.6.5" - extra["versions.jar.gson"] = "2.8.2" + extra["versions.jar.gson"] = "2.8.4" extra["versions.jar.oro"] = "2.0.8" - extra["versions.jar.snappy-in-java"] = "0.5.1" + extra["versions.jar.picocontainer"] = "1.2" for (jar in gradleJars) { extra["versions.jar.$jar"] = "4.4" } + extra["ignore.jar.snappy-in-java"] = true extra["ignore.jar.common"] = true extra["ignore.jar.lombok-ast"] = true }