as32: Update to AS 3.2 C10

2018-04-12 15:19:46 +03:00
parent 6fab21f916
commit 4299455dc1
98 changed files with 9321 additions and 7 deletions
@@ -0,0 +1,51 @@
+/*
+ * 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.framework;
+
+import com.intellij.framework.library.LibraryVersionProperties;
+import com.intellij.openapi.roots.libraries.LibraryPresentationProvider;
+import com.intellij.openapi.roots.libraries.LibraryProperties;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.KotlinIcons;
+
+import javax.swing.*;
+import java.util.List;
+
+public class JavaRuntimePresentationProvider extends LibraryPresentationProvider<LibraryVersionProperties> {
+    public static JavaRuntimePresentationProvider getInstance() {
+        return LibraryPresentationProvider.EP_NAME.findExtension(JavaRuntimePresentationProvider.class);
+    }
+
+    protected JavaRuntimePresentationProvider() {
+        super(JavaRuntimeLibraryDescription.Companion.getKOTLIN_JAVA_RUNTIME_KIND());
+    }
+
+    @Nullable
+    @Override
+    public Icon getIcon(@Nullable LibraryVersionProperties properties) {
+        return KotlinIcons.SMALL_LOGO;
+    }
+
+    @Nullable
+    @Override
+    public LibraryVersionProperties detect(@NotNull List<VirtualFile> classesRoots) {
+        String version = JavaRuntimeDetectionUtil.getJavaRuntimeVersion(classesRoots);
+        return version == null ? null : new LibraryVersionProperties(version);
+    }
+}
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2000-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.quickfix
+
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ex.ProjectRootManagerEx
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.idea.compiler.configuration.KotlinCommonCompilerArgumentsHolder
+import org.jetbrains.kotlin.idea.configuration.BuildSystemType
+import org.jetbrains.kotlin.idea.configuration.findApplicableConfigurator
+import org.jetbrains.kotlin.idea.configuration.getBuildSystemType
+import org.jetbrains.kotlin.idea.facet.KotlinFacet
+
+import org.jetbrains.kotlin.psi.KtFile
+
+sealed class ChangeCoroutineSupportFix(
+        element: PsiElement,
+        protected val coroutineSupport: LanguageFeature.State
+) : KotlinQuickFixAction<PsiElement>(element) {
+    protected val coroutineSupportEnabled: Boolean
+            get() = coroutineSupport == LanguageFeature.State.ENABLED || coroutineSupport == LanguageFeature.State.ENABLED_WITH_WARNING
+
+    class InModule(element: PsiElement, coroutineSupport: LanguageFeature.State) : ChangeCoroutineSupportFix(element, coroutineSupport) {
+        override fun getText() = "${super.getText()} in the current module"
+
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+            val module = ModuleUtilCore.findModuleForPsiElement(file) ?: return
+
+            findApplicableConfigurator(module).changeCoroutineConfiguration(module, coroutineSupport)
+        }
+    }
+
+    class InProject(element: PsiElement, coroutineSupport: LanguageFeature.State) : ChangeCoroutineSupportFix(element, coroutineSupport) {
+        override fun getText() = "${super.getText()} in the project"
+
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+            if (coroutineSupportEnabled) {
+                if (!checkUpdateRuntime(project, LanguageFeature.Coroutines.sinceApiVersion)) return
+            }
+
+            KotlinCommonCompilerArgumentsHolder.getInstance(project).update {
+                coroutinesState = when (coroutineSupport) {
+                    LanguageFeature.State.ENABLED -> CommonCompilerArguments.ENABLE
+                    LanguageFeature.State.ENABLED_WITH_WARNING -> CommonCompilerArguments.WARN
+                    LanguageFeature.State.ENABLED_WITH_ERROR, LanguageFeature.State.DISABLED -> CommonCompilerArguments.ERROR
+                }
+            }
+            ProjectRootManagerEx.getInstanceEx(project).makeRootsChange({}, false, true)
+        }
+
+    }
+
+    override fun getFamilyName() = "Enable/Disable coroutine support"
+
+    override fun getText(): String {
+        return getFixText(coroutineSupport)
+    }
+
+    companion object : KotlinIntentionActionsFactory() {
+        fun getFixText(state: LanguageFeature.State): String {
+            return when (state) {
+                LanguageFeature.State.ENABLED -> "Enable coroutine support"
+                LanguageFeature.State.ENABLED_WITH_WARNING -> "Enable coroutine support (with warning)"
+                LanguageFeature.State.ENABLED_WITH_ERROR, LanguageFeature.State.DISABLED -> "Disable coroutine support"
+            }
+        }
+
+        override fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction> {
+            val newCoroutineSupports = when (diagnostic.factory) {
+                Errors.EXPERIMENTAL_FEATURE_ERROR -> {
+                    if (Errors.EXPERIMENTAL_FEATURE_ERROR.cast(diagnostic).a.first != LanguageFeature.Coroutines) return emptyList()
+                    listOf(LanguageFeature.State.ENABLED_WITH_WARNING, LanguageFeature.State.ENABLED)
+                }
+                Errors.EXPERIMENTAL_FEATURE_WARNING -> {
+                    if (Errors.EXPERIMENTAL_FEATURE_WARNING.cast(diagnostic).a.first != LanguageFeature.Coroutines) return emptyList()
+                    listOf(LanguageFeature.State.ENABLED, LanguageFeature.State.ENABLED_WITH_ERROR)
+                }
+                else -> return emptyList()
+            }
+            val module = ModuleUtilCore.findModuleForPsiElement(diagnostic.psiElement) ?: return emptyList()
+            val facetSettings = KotlinFacet.get(module)?.configuration?.settings
+
+            val configureInProject = (facetSettings == null || facetSettings.useProjectSettings) &&
+                                     module.getBuildSystemType() == BuildSystemType.JPS
+            val quickFixConstructor: (PsiElement, LanguageFeature.State) -> ChangeCoroutineSupportFix =
+                    if (configureInProject) ::InProject else ::InModule
+            return newCoroutineSupports.map { quickFixConstructor(diagnostic.psiElement, it) }
+        }
+    }
+}