183: Build against 183-SNAPSHOT

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<out PsiAnnotation> = EMPTY_PSI_ANNOTATION_ARRAY
+    override fun isInferredAnnotation(annotation: PsiAnnotation): Boolean = false
+
+    companion object {
+        val EMPTY_PSI_ANNOTATION_ARRAY = arrayOf<PsiAnnotation>()
+    }
+}

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<FileNameMatcher> 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<FileNameMatcher> 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;
+    }
+}

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<Module> myAdditionalModules;
+
+    protected AndroidFacet myFacet;
+    protected CodeStyleSettings mySettings;
+
+    private List<String> myAllowedRoots = new ArrayList<>();
+    private boolean myUseCustomSettings;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory());
+
+        TestFixtureBuilder<IdeaProjectTestFixture> 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<MyAdditionalModuleData> 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<String> 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<String> roots) throws IOException {
+    }
+
+    private void registerAllowedRoots(List<String> roots, @NotNull Disposable disposable) {
+        List<String> 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<IdeaProjectTestFixture> projectBuilder, @NotNull List<MyAdditionalModuleData> modules) {
+    }
+
+    protected final void addModuleWithAndroidFacet(
+            @NotNull TestFixtureBuilder<IdeaProjectTestFixture> projectBuilder,
+            @NotNull List<MyAdditionalModuleData> 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<IdeaProjectTestFixture> projectBuilder,
+            @NotNull List<MyAdditionalModuleData> 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> T registerApplicationComponent(@NotNull Class<T> 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> T registerProjectComponent(@NotNull Class<T> 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;
+    }
+}

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
+}