diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockInferredAnnotationsManager.kt.183 b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockInferredAnnotationsManager.kt.183 new file mode 100644 index 00000000000..40695a91a5b --- /dev/null +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockInferredAnnotationsManager.kt.183 @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2016 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.cli.jvm.compiler + +import com.intellij.codeInsight.InferredAnnotationsManager +import com.intellij.psi.PsiAnnotation +import com.intellij.psi.PsiModifierListOwner + +class MockInferredAnnotationsManager : InferredAnnotationsManager() { + override fun findInferredAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null + override fun findInferredAnnotations(listOwner: PsiModifierListOwner): Array = EMPTY_PSI_ANNOTATION_ARRAY + override fun isInferredAnnotation(annotation: PsiAnnotation): Boolean = false + + companion object { + val EMPTY_PSI_ANNOTATION_ARRAY = arrayOf() + } +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/mock/KtMockFileTypeManager.java.183 b/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/mock/KtMockFileTypeManager.java.183 new file mode 100644 index 00000000000..ef8743d263b --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/mock/KtMockFileTypeManager.java.183 @@ -0,0 +1,161 @@ +/* + * Copyright 2010-2016 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.test.testFramework.mock; + +import com.intellij.openapi.fileTypes.*; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.ArrayUtil; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +public class KtMockFileTypeManager extends FileTypeManager { + private final FileType fileType; + + public KtMockFileTypeManager(FileType fileType) { + this.fileType = fileType; + } + + @Override + @NotNull + public String getIgnoredFilesList() { + throw new IncorrectOperationException(); + } + + @Override + public void setIgnoredFilesList(@NotNull String list) { + } + + @Override + public void registerFileType(@NotNull FileType type, @NotNull List defaultAssociations) { + } + + @Override + @NotNull + public FileType getFileTypeByFileName(@NotNull String fileName) { + return fileType; + } + + @Override + @NotNull + public FileType getFileTypeByFile(@NotNull VirtualFile file) { + return fileType; + } + + @Override + @NotNull + public FileType getFileTypeByExtension(@NotNull String extension) { + return fileType; + } + + @Override + @NotNull + public FileType[] getRegisteredFileTypes() { + return FileType.EMPTY_ARRAY; + } + + @Override + public boolean isFileIgnored(@NotNull String name) { + return false; + } + + @Override + public boolean isFileIgnored(@NotNull VirtualFile file) { + return false; + } + + @Override + @NotNull + public String[] getAssociatedExtensions(@NotNull FileType type) { + return ArrayUtil.EMPTY_STRING_ARRAY; + } + + @Override + public void addFileTypeListener(@NotNull FileTypeListener listener) { + } + + @Override + public void removeFileTypeListener(@NotNull FileTypeListener listener) { + } + + @Override + public FileType getKnownFileTypeOrAssociate(@NotNull VirtualFile file) { + return file.getFileType(); + } + + @Override + public FileType getKnownFileTypeOrAssociate(@NotNull VirtualFile file, @NotNull Project project) { + return getKnownFileTypeOrAssociate(file); + } + + @Override + @NotNull + public List getAssociations(@NotNull FileType type) { + return Collections.emptyList(); + } + + @Override + public void associate(@NotNull FileType type, @NotNull FileNameMatcher matcher) { + } + + @Override + public void removeAssociation(@NotNull FileType type, @NotNull FileNameMatcher matcher) { + } + + @Override + @NotNull + public FileType getStdFileType(@NotNull @NonNls String fileTypeName) { + if ("ARCHIVE".equals(fileTypeName) || "CLASS".equals(fileTypeName)) return UnknownFileType.INSTANCE; + if ("PLAIN_TEXT".equals(fileTypeName)) return PlainTextFileType.INSTANCE; + if ("JAVA".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.JavaFileType", fileTypeName); + if ("XML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.XmlFileType", fileTypeName); + if ("DTD".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.DTDFileType", fileTypeName); + if ("JSP".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.NewJspFileType", fileTypeName); + if ("JSPX".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.JspxFileType", fileTypeName); + if ("HTML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.HtmlFileType", fileTypeName); + if ("XHTML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.XHtmlFileType", fileTypeName); + if ("JavaScript".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.lang.javascript.JavaScriptFileType", fileTypeName); + if ("Properties".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.lang.properties.PropertiesFileType", fileTypeName); + return new KtMockLanguageFileType(PlainTextLanguage.INSTANCE, fileTypeName.toLowerCase()); + } + + private static FileType loadFileTypeSafe(String className, String fileTypeName) { + try { + return (FileType)Class.forName(className).getField("INSTANCE").get(null); + } + catch (Exception ignored) { + return new KtMockLanguageFileType(PlainTextLanguage.INSTANCE, fileTypeName.toLowerCase(Locale.ENGLISH)); + } + } + + @Override + public boolean isFileOfType(@NotNull VirtualFile file, @NotNull FileType type) { + return false; + } + + @Nullable + @Override + public FileType findFileTypeByName(@NotNull String fileTypeName) { + return null; + } +} \ No newline at end of file diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/AndroidTestCase.java.183 b/idea/idea-android/tests/org/jetbrains/kotlin/android/AndroidTestCase.java.183 new file mode 100644 index 00000000000..1fcd2b5ab71 --- /dev/null +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/AndroidTestCase.java.183 @@ -0,0 +1,386 @@ +/* + * Copyright 2000-2009 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.android; + +import com.android.SdkConstants; +import com.android.tools.idea.rendering.RenderSecurityManager; +import com.android.tools.idea.startup.AndroidCodeStyleSettingsModifier; +import com.intellij.analysis.AnalysisScope; +import com.intellij.codeInspection.GlobalInspectionTool; +import com.intellij.codeInspection.ex.GlobalInspectionToolWrapper; +import com.intellij.facet.FacetManager; +import com.intellij.facet.ModifiableFacetModel; +import com.intellij.openapi.Disposable; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.projectRoots.ProjectJdkTable; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.roots.LanguageLevelProjectExtension; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess; +import com.intellij.pom.java.LanguageLevel; +import com.intellij.psi.codeStyle.CodeStyleSchemes; +import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.testFramework.InspectionTestUtil; +import com.intellij.testFramework.InspectionsKt; +import com.intellij.testFramework.ThreadTracker; +import com.intellij.testFramework.builders.JavaModuleFixtureBuilder; +import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory; +import com.intellij.testFramework.fixtures.JavaTestFixtureFactory; +import com.intellij.testFramework.fixtures.TestFixtureBuilder; +import com.intellij.testFramework.fixtures.impl.GlobalInspectionContextForTests; +import com.intellij.util.ArrayUtil; +import org.jetbrains.android.facet.AndroidFacet; +import org.jetbrains.android.facet.AndroidRootUtil; +import org.jetbrains.android.formatter.AndroidXmlCodeStyleSettings; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.picocontainer.MutablePicoContainer; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Copied from AS 2.3 sources + */ +@SuppressWarnings({"JUnitTestCaseWithNonTrivialConstructors"}) +public abstract class AndroidTestCase extends AndroidTestBase { + protected Module myModule; + protected List myAdditionalModules; + + protected AndroidFacet myFacet; + protected CodeStyleSettings mySettings; + + private List myAllowedRoots = new ArrayList<>(); + private boolean myUseCustomSettings; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()); + + TestFixtureBuilder projectBuilder = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder(getName()); + myFixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(projectBuilder.getFixture()); + JavaModuleFixtureBuilder moduleFixtureBuilder = projectBuilder.addModule(JavaModuleFixtureBuilder.class); + File moduleRoot = new File(myFixture.getTempDirPath()); + + if (!moduleRoot.exists()) { + assertTrue(moduleRoot.mkdirs()); + } + initializeModuleFixtureBuilderWithSrcAndGen(moduleFixtureBuilder, moduleRoot.toString()); + + ArrayList modules = new ArrayList<>(); + configureAdditionalModules(projectBuilder, modules); + + myFixture.setUp(); + myFixture.setTestDataPath(getTestDataPath()); + myModule = moduleFixtureBuilder.getFixture().getModule(); + + // Must be done before addAndroidFacet, and must always be done, even if a test provides + // its own custom manifest file. However, in that case, we will delete it shortly below. + createManifest(); + + myFacet = addAndroidFacet(myModule); + + LanguageLevel languageLevel = getLanguageLevel(); + if (languageLevel != null) { + LanguageLevelProjectExtension extension = LanguageLevelProjectExtension.getInstance(myModule.getProject()); + if (extension != null) { + extension.setLanguageLevel(languageLevel); + } + } + + // TODO: myFixture.copyDirectoryToProject(getResDir(), "res"); + + myAdditionalModules = new ArrayList<>(); + for (MyAdditionalModuleData data : modules) { + Module additionalModule = data.myModuleFixtureBuilder.getFixture().getModule(); + myAdditionalModules.add(additionalModule); + AndroidFacet facet = addAndroidFacet(additionalModule); + facet.getProperties().PROJECT_TYPE = data.myProjectType; + String rootPath = getAdditionalModulePath(data.myDirName); + myFixture.copyDirectoryToProject(getResDir(), rootPath + "/res"); + myFixture.copyFileToProject(SdkConstants.FN_ANDROID_MANIFEST_XML, rootPath + '/' + SdkConstants.FN_ANDROID_MANIFEST_XML); + if (data.myIsMainModuleDependency) { + ModuleRootModificationUtil.addDependency(myModule, additionalModule); + } + } + + if (providesCustomManifest()) { + deleteManifest(); + } + + if (RenderSecurityManager.RESTRICT_READS) { + // Unit test class loader includes disk directories which security manager does not allow access to + RenderSecurityManager.sEnabled = false; + } + + ArrayList allowedRoots = new ArrayList<>(); + collectAllowedRoots(allowedRoots); + // TODO: registerAllowedRoots(allowedRoots, myTestRootDisposable); + mySettings = CodeStyleSettingsManager.getSettings(getProject()).clone(); + AndroidCodeStyleSettingsModifier.modify(mySettings); + CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(mySettings); + myUseCustomSettings = getAndroidCodeStyleSettings().USE_CUSTOM_SETTINGS; + getAndroidCodeStyleSettings().USE_CUSTOM_SETTINGS = true; + + // Layoutlib rendering thread will be shutdown when the app is closed so do not report it as a leak + ThreadTracker.longRunningThreadCreated(ApplicationManager.getApplication(), "Layoutlib"); + } + + @Override + protected void tearDown() throws Exception { + try { + Sdk androidSdk = ProjectJdkTable.getInstance().findJdk(ANDROID_SDK_NAME); + if (androidSdk != null) { + ApplicationManager.getApplication().runWriteAction(() -> ProjectJdkTable.getInstance().removeJdk(androidSdk)); + } + + CodeStyleSettingsManager.getInstance(getProject()).dropTemporarySettings(); + myModule = null; + myAdditionalModules = null; + myFixture.tearDown(); + myFixture = null; + myFacet = null; + getAndroidCodeStyleSettings().USE_CUSTOM_SETTINGS = myUseCustomSettings; + if (RenderSecurityManager.RESTRICT_READS) { + RenderSecurityManager.sEnabled = true; + } + } + finally { + super.tearDown(); + VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()); + } + } + + private static void initializeModuleFixtureBuilderWithSrcAndGen(JavaModuleFixtureBuilder moduleFixtureBuilder, String moduleRoot) { + moduleFixtureBuilder.addContentRoot(moduleRoot); + + //noinspection ResultOfMethodCallIgnored + new File(moduleRoot + "/src/").mkdir(); + moduleFixtureBuilder.addSourceRoot("src"); + + //noinspection ResultOfMethodCallIgnored + new File(moduleRoot + "/gen/").mkdir(); + moduleFixtureBuilder.addSourceRoot("gen"); + } + + /** + * Returns the path that any additional modules registered by + * {@link #configureAdditionalModules(TestFixtureBuilder, List)} or + * {@link #addModuleWithAndroidFacet(TestFixtureBuilder, List, String, int, boolean)} are + * installed into. + */ + protected static String getAdditionalModulePath(@NotNull String moduleName) { + return "/additionalModules/" + moduleName; + } + + /** + * Indicates whether this class provides its own {@code AndroidManifest.xml} for its tests. If + * {@code true}, then {@link #setUp()} calls {@link #deleteManifest()} before finishing. + */ + protected boolean providesCustomManifest() { + return false; + } + + /** + * Get the "res" directory for this SDK. Children classes can override this if they need to + * provide a custom "res" location for tests. + */ + protected String getResDir() { + return "res"; + } + + /** + * Defines the project level to set for the test project, or null to get the default language + * level associated with the test project. + */ + @Nullable + protected LanguageLevel getLanguageLevel() { + return null; + } + + protected static AndroidXmlCodeStyleSettings getAndroidCodeStyleSettings() { + return AndroidXmlCodeStyleSettings.getInstance(CodeStyleSchemes.getInstance().getDefaultScheme().getCodeStyleSettings()); + } + + /** + * Hook point for child test classes to register directories that can be safely accessed by all + * of its tests. + * + * @see {@link VfsRootAccess} + */ + protected void collectAllowedRoots(List roots) throws IOException { + } + + private void registerAllowedRoots(List roots, @NotNull Disposable disposable) { + List newRoots = new ArrayList<>(roots); + newRoots.removeAll(myAllowedRoots); + + String[] newRootsArray = ArrayUtil.toStringArray(newRoots); + VfsRootAccess.allowRootAccess(newRootsArray); + myAllowedRoots.addAll(newRoots); + + Disposer.register(disposable, () -> { + VfsRootAccess.disallowRootAccess(newRootsArray); + myAllowedRoots.removeAll(newRoots); + }); + } + + public static AndroidFacet addAndroidFacet(Module module) { + return addAndroidFacet(module, true); + } + + private static AndroidFacet addAndroidFacet(Module module, boolean attachSdk) { + FacetManager facetManager = FacetManager.getInstance(module); + AndroidFacet facet = facetManager.createFacet(AndroidFacet.getFacetType(), "Android", null); + + if (attachSdk) { + addLatestAndroidSdk(module); + } + ModifiableFacetModel facetModel = facetManager.createModifiableModel(); + facetModel.addFacet(facet); + ApplicationManager.getApplication().runWriteAction(facetModel::commit); + return facet; + } + + protected void configureAdditionalModules( + @NotNull TestFixtureBuilder projectBuilder, @NotNull List modules) { + } + + protected final void addModuleWithAndroidFacet( + @NotNull TestFixtureBuilder projectBuilder, + @NotNull List modules, + @NotNull String dirName, + int projectType) { + // By default, created module is declared as a main module's dependency + addModuleWithAndroidFacet(projectBuilder, modules, dirName, projectType, true); + } + + protected final void addModuleWithAndroidFacet( + @NotNull TestFixtureBuilder projectBuilder, + @NotNull List modules, + @NotNull String dirName, + int projectType, + boolean isMainModuleDependency) { + JavaModuleFixtureBuilder moduleFixtureBuilder = projectBuilder.addModule(JavaModuleFixtureBuilder.class); + String moduleDirPath = myFixture.getTempDirPath() + getAdditionalModulePath(dirName); + //noinspection ResultOfMethodCallIgnored + new File(moduleDirPath).mkdirs(); + initializeModuleFixtureBuilderWithSrcAndGen(moduleFixtureBuilder, moduleDirPath); + modules.add(new MyAdditionalModuleData(moduleFixtureBuilder, dirName, projectType, isMainModuleDependency)); + } + + protected void createManifest() throws IOException { + myFixture.copyFileToProject(SdkConstants.FN_ANDROID_MANIFEST_XML, SdkConstants.FN_ANDROID_MANIFEST_XML); + } + + protected final void createProjectProperties() throws IOException { + myFixture.copyFileToProject(SdkConstants.FN_PROJECT_PROPERTIES, SdkConstants.FN_PROJECT_PROPERTIES); + } + + protected final void deleteManifest() throws IOException { + deleteManifest(myModule); + } + + protected final void deleteManifest(final Module module) throws IOException { + AndroidFacet facet = AndroidFacet.getInstance(module); + assertNotNull(facet); + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + String manifestRelativePath = facet.getProperties().MANIFEST_FILE_RELATIVE_PATH; + VirtualFile manifest = AndroidRootUtil.getFileByRelativeModulePath(module, manifestRelativePath, true); + if (manifest != null) { + try { + manifest.delete(this); + } + catch (IOException e) { + fail("Could not delete default manifest"); + } + } + } + }); + } + + protected final void doGlobalInspectionTest( + @NotNull GlobalInspectionTool inspection, @NotNull String globalTestDir, @NotNull AnalysisScope scope) { + doGlobalInspectionTest(new GlobalInspectionToolWrapper(inspection), globalTestDir, scope); + } + + /** + * Given an inspection and a path to a directory that contains an "expected.xml" file, run the + * inspection on the current test project and verify that its output matches that of the + * expected file. + */ + protected final void doGlobalInspectionTest( + @NotNull GlobalInspectionToolWrapper wrapper, @NotNull String globalTestDir, @NotNull AnalysisScope scope) { + myFixture.enableInspections(wrapper.getTool()); + + scope.invalidate(); + + GlobalInspectionContextForTests globalContext = + InspectionsKt.createGlobalContextForTool(scope, getProject(), Collections.singletonList(wrapper)); + + InspectionTestUtil.runTool(wrapper, scope, globalContext); + InspectionTestUtil.compareToolResults(globalContext, wrapper, false, getTestDataPath() + globalTestDir); + } + + protected static class MyAdditionalModuleData { + final JavaModuleFixtureBuilder myModuleFixtureBuilder; + final String myDirName; + final int myProjectType; + final boolean myIsMainModuleDependency; + + private MyAdditionalModuleData( + @NotNull JavaModuleFixtureBuilder moduleFixtureBuilder, @NotNull String dirName, int projectType, boolean isMainModuleDependency) { + myModuleFixtureBuilder = moduleFixtureBuilder; + myDirName = dirName; + myProjectType = projectType; + myIsMainModuleDependency = isMainModuleDependency; + } + } + + @NotNull + protected T registerApplicationComponent(@NotNull Class key, @NotNull T instance) throws Exception { + MutablePicoContainer picoContainer = (MutablePicoContainer)ApplicationManager.getApplication().getPicoContainer(); + @SuppressWarnings("unchecked") + T old = (T)picoContainer.getComponentInstance(key.getName()); + picoContainer.unregisterComponent(key.getName()); + picoContainer.registerComponentInstance(key.getName(), instance); + return old; + } + + @NotNull + protected T registerProjectComponent(@NotNull Class key, @NotNull T instance) { + MutablePicoContainer picoContainer = (MutablePicoContainer)getProject().getPicoContainer(); + @SuppressWarnings("unchecked") + T old = (T)picoContainer.getComponentInstance(key.getName()); + picoContainer.unregisterComponent(key.getName()); + picoContainer.registerComponentInstance(key.getName(), instance); + return old; + } +} diff --git a/versions.gradle.kts.183 b/versions.gradle.kts.183 new file mode 100644 index 00000000000..8ac57dd1e39 --- /dev/null +++ b/versions.gradle.kts.183 @@ -0,0 +1,155 @@ +extra["versions.intellijSdk"] = "183-SNAPSHOT" +extra["versions.androidBuildTools"] = "r23.0.1" +extra["versions.idea.NodeJS"] = "181.3494.12" +//extra["versions.androidStudioRelease"] = "3.1.0.5" +//extra["versions.androidStudioBuild"] = "173.4506631" + +val gradleJars = listOf( + "gradle-api", + "gradle-tooling-api", + "gradle-base-services", + "gradle-wrapper", + "gradle-core", + "gradle-base-services-groovy" +) + +val androidStudioVersion = if (extra.has("versions.androidStudioRelease")) + extra["versions.androidStudioRelease"]?.toString()?.replace(".", "")?.substring(0, 2) +else + null + +val intellijVersion = rootProject.extra["versions.intellijSdk"] as String +val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-')) +if (intellijVersionDelimiterIndex == -1) { + error("Invalid IDEA version $intellijVersion") +} + +val platformBaseVersion = intellijVersion.substring(0, intellijVersionDelimiterIndex) +val platform = androidStudioVersion?.let { "AS$it" } ?: platformBaseVersion + +when (platform) { + "183" -> { + extra["versions.jar.guava"] = "25.1-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.7" + extra["versions.jar.gson"] = "2.8.4" + extra["versions.jar.oro"] = "2.0.8" + extra["versions.jar.picocontainer"] = "1.2" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.5.1" + } + + extra["ignore.jar.snappy-in-java"] = true + } + "182" -> { + 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.4" + extra["versions.jar.oro"] = "2.0.8" + extra["versions.jar.picocontainer"] = "1.2" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.5.1" + } + + extra["ignore.jar.snappy-in-java"] = true + } + "181" -> { + extra["versions.jar.guava"] = "21.0" + extra["versions.jar.groovy-all"] = "2.4.12" + 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.oro"] = "2.0.8" + extra["versions.jar.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.4" + } + } + "173" -> { + extra["versions.jar.guava"] = "21.0" + extra["versions.jar.groovy-all"] = "2.4.12" + extra["versions.jar.lombok-ast"] = "0.2.3" + extra["versions.jar.swingx-core"] = "1.6.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.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.0" + } + extra["ignore.jar.lombok-ast-0.2.3"] = true + } + "172" -> { + extra["versions.jar.guava"] = "21.0" + extra["versions.jar.groovy-all"] = "2.4.6" + extra["versions.jar.lombok-ast"] = "0.2.3" + extra["versions.jar.swingx-core"] = "1.6.2" + extra["versions.jar.kxml2"] = "2.3.0" + extra["versions.jar.streamex"] = "0.6.2" + extra["versions.jar.gson"] = "2.5" + extra["versions.jar.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "3.5" + } + } + "AS31" -> { + 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.kxml2"] = "2.3.0" + extra["versions.jar.streamex"] = "0.6.5" + extra["versions.jar.gson"] = "2.8.2" + extra["versions.jar.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.0" + } + + extra["ignore.jar.common"] = true + extra["ignore.jar.lombok-ast"] = true + } + "AS32" -> { + 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.kxml2"] = "2.3.0" + extra["versions.jar.streamex"] = "0.6.5" + extra["versions.jar.gson"] = "2.8.2" + extra["versions.jar.oro"] = "2.0.8" + extra["versions.jar.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.4" + } + + extra["ignore.jar.common"] = true + 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.kxml2"] = "2.3.0" + extra["versions.jar.streamex"] = "0.6.5" + extra["versions.jar.gson"] = "2.8.2" + extra["versions.jar.oro"] = "2.0.8" + extra["versions.jar.snappy-in-java"] = "0.5.1" + for (jar in gradleJars) { + extra["versions.jar.$jar"] = "4.4" + } + + extra["ignore.jar.common"] = true + extra["ignore.jar.lombok-ast"] = true + } +} + +if (!extra.has("versions.androidStudioRelease")) { + extra["ignore.jar.android-base-common"] = true +}