Extract module 'config' out of 'frontend'

Also move deprecated TargetPlatform there. This allows to get rid of the dependency cli.common -> frontend, and even on frontend.common.
2020-03-15 00:00:33 +01:00
parent 143aef938b
commit 4dcd0d1cb6
14 changed files with 23 additions and 4 deletions
@@ -0,0 +1,15 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(project(":core:descriptors"))
+    api(project(":compiler:util"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {}
+}
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.config
+
+object AnalysisFlags {
+    @JvmStatic
+    val skipMetadataVersionCheck by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val multiPlatformDoNotCheckActual by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val klibBasedMpp by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val experimental by AnalysisFlag.Delegates.ListOfStrings
+
+    @JvmStatic
+    val useExperimental by AnalysisFlag.Delegates.ListOfStrings
+
+    @JvmStatic
+    val explicitApiVersion by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val ignoreDataFlowInAssert by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val allowResultReturnType by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val explicitApiMode by AnalysisFlag.Delegates.ApiModeDisabledByDefault
+
+    @JvmStatic
+    val constraintSystemForOverloadResolution by AnalysisFlag.Delegates.ConstraintSystemForOverloadResolution
+
+    @JvmStatic
+    val useTypeRefinement by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val ideMode by AnalysisFlag.Delegates.Boolean
+
+    @JvmStatic
+    val reportErrorsOnIrDependencies by AnalysisFlag.Delegates.Boolean
+}
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2017 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.config
+
+import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
+
+object CommonConfigurationKeys {
+    @JvmField
+    val LANGUAGE_VERSION_SETTINGS = CompilerConfigurationKey<LanguageVersionSettings>("language version settings")
+
+    @JvmField
+    val DISABLE_INLINE = CompilerConfigurationKey<Boolean>("disable inline")
+
+    @JvmField
+    val MODULE_NAME = CompilerConfigurationKey<String>("module name")
+
+    @JvmField
+    val REPORT_OUTPUT_FILES = CompilerConfigurationKey<Boolean>("report output files")
+
+    @JvmField
+    val LOOKUP_TRACKER = CompilerConfigurationKey.create<LookupTracker>("lookup tracker")
+
+    @JvmField
+    val EXPECT_ACTUAL_TRACKER = CompilerConfigurationKey.create<ExpectActualTracker>("expect actual tracker")
+
+    @JvmField
+    val METADATA_VERSION = CompilerConfigurationKey.create<BinaryVersion>("metadata version")
+
+    @JvmField
+    val USE_FIR = CompilerConfigurationKey.create<Boolean>("front-end IR")
+
+    @JvmField
+    val KLIB_MPP = CompilerConfigurationKey.create<Boolean>("Klib based MPP")
+}
+
+var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings
+    get() = get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+    set(value) = put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, value)
+
+val LanguageVersionSettings.isTypeRefinementEnabled: Boolean
+    get() = getFlag(AnalysisFlags.useTypeRefinement)
@@ -0,0 +1,169 @@
+/*
+ * 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.config;
+
+import com.intellij.openapi.util.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class CompilerConfiguration {
+    public static CompilerConfiguration EMPTY = new CompilerConfiguration();
+
+    private final Map<Key, Object> map = new LinkedHashMap<>();
+    private boolean readOnly = false;
+
+    static {
+        EMPTY.setReadOnly(true);
+    }
+
+    @Nullable
+    public <T> T get(@NotNull CompilerConfigurationKey<T> key) {
+        T data = (T) map.get(key.ideaKey);
+        return data == null ? null : unmodifiable(data);
+    }
+
+    @NotNull
+    public <T> T get(@NotNull CompilerConfigurationKey<T> key, @NotNull T defaultValue) {
+        T data = get(key);
+        return data == null ? defaultValue : data;
+    }
+
+    @NotNull
+    public <T> T getNotNull(@NotNull CompilerConfigurationKey<T> key) {
+        T data = get(key);
+        assert data != null : "No value for configuration key: " + key;
+        return data;
+    }
+
+    public boolean getBoolean(@NotNull CompilerConfigurationKey<Boolean> key) {
+        return get(key, false);
+    }
+
+    @NotNull
+    public <T> List<T> getList(@NotNull CompilerConfigurationKey<List<T>> key) {
+        List<T> data = get(key);
+        return data == null ? Collections.emptyList() : data;
+    }
+
+    @NotNull
+    public <K, V> Map<K, V> getMap(@NotNull CompilerConfigurationKey<Map<K, V>> key) {
+        Map<K, V> data = get(key);
+        return data == null ? Collections.emptyMap() : data;
+    }
+
+    public <T> void put(@NotNull CompilerConfigurationKey<T> key, @NotNull T value) {
+        checkReadOnly();
+        map.put(key.ideaKey, value);
+    }
+
+    public <T> void putIfNotNull(@NotNull CompilerConfigurationKey<T> key, @Nullable T value) {
+        if (value != null) {
+            put(key, value);
+        }
+    }
+
+    public <T> void add(@NotNull CompilerConfigurationKey<List<T>> key, @NotNull T value) {
+        checkReadOnly();
+        Key<List<T>> ideaKey = key.ideaKey;
+        map.computeIfAbsent(ideaKey, k -> new ArrayList<T>());
+        List<T> list = (List<T>) map.get(ideaKey);
+        list.add(value);
+    }
+
+    public <K, V> void put(@NotNull CompilerConfigurationKey<Map<K, V>> configurationKey, @NotNull K key, @NotNull V value) {
+        checkReadOnly();
+        Key<Map<K, V>> ideaKey = configurationKey.ideaKey;
+        map.computeIfAbsent(ideaKey, k -> new HashMap<K, V>());
+        Map<K, V> data = (Map<K, V>) map.get(ideaKey);
+        data.put(key, value);
+    }
+
+    public <T> void addAll(@NotNull CompilerConfigurationKey<List<T>> key, @Nullable Collection<T> values) {
+        if (values != null) {
+            addAll(key, getList(key).size(), values);
+        }
+    }
+
+    public <T> void addAll(@NotNull CompilerConfigurationKey<List<T>> key, int index, @NotNull Collection<T> values) {
+        checkReadOnly();
+        checkForNullElements(values);
+        Key<List<T>> ideaKey = key.ideaKey;
+        map.computeIfAbsent(ideaKey, k -> new ArrayList<T>());
+        List<T> list = (List<T>) map.get(ideaKey);
+        list.addAll(index, values);
+    }
+
+    public CompilerConfiguration copy() {
+        CompilerConfiguration copy = new CompilerConfiguration();
+        copy.map.putAll(map);
+        return copy;
+    }
+
+    private void checkReadOnly() {
+        if (readOnly) {
+            throw new IllegalStateException("CompilerConfiguration is read-only");
+        }
+    }
+
+    public void setReadOnly(boolean readOnly) {
+        if (readOnly != this.readOnly) {
+            this.readOnly = readOnly;
+        }
+    }
+
+    public boolean isReadOnly() {
+        return readOnly;
+    }
+
+    @NotNull
+    private static <T> T unmodifiable(@NotNull T object) {
+        if (object instanceof List) {
+            return (T) Collections.unmodifiableList((List) object);
+        }
+        else if (object instanceof Map) {
+            return (T) Collections.unmodifiableMap((Map) object);
+        }
+        else if (object instanceof Set) {
+            return (T) Collections.unmodifiableSet((Set) object);
+        }
+        else if (object instanceof Collection) {
+            return (T) Collections.unmodifiableCollection((Collection) object);
+        }
+        else {
+            return object;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return map.toString();
+    }
+
+    private static <T> void checkForNullElements(Collection<T> values) {
+        int index = 0;
+        for (T value : values) {
+            if (value == null) {
+                throw new IllegalArgumentException("Element " + index
+                                                   + " is null, while null values in compiler configuration are not allowed");
+            }
+            index++;
+        }
+    }
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.config;
+
+import com.intellij.openapi.util.Key;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+
+public class CompilerConfigurationKey<T> {
+    Key<T> ideaKey;
+
+    public CompilerConfigurationKey(@NotNull @NonNls String name) {
+        ideaKey = Key.create(name);
+    }
+
+    @NotNull
+    public static <T> CompilerConfigurationKey<T> create(@NotNull @NonNls String name) {
+        return new CompilerConfigurationKey<>(name);
+    }
+
+    @Override
+    public String toString() {
+        return ideaKey.toString();
+    }
+}
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.resolve
+
+@Deprecated(
+    message = "This class is deprecated and will be removed soon, use API from 'org.jetbrains.kotlin.platform.*' packages instead",
+    replaceWith = ReplaceWith("TargetPlatform", "org.jetbrains.kotlin.platform.TargetPlatform"),
+    level = DeprecationLevel.ERROR
+)
+interface TargetPlatform {
+    val platformName: String
+}