azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extract module 'config' out of 'frontend'

Browse Source 
Also move deprecated TargetPlatform there. This allows to get rid of the
dependency cli.common -> frontend, and even on frontend.common.
This commit is contained in:
Alexander Udalov
2020-03-15 00:00:33 +01:00
committed by Alexander Udalov
parent 143aef938b
commit 4dcd0d1cb6
14 changed files with 23 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/build.gradle.kts
+1 -1
View File
@@ -1,4 +1,3 @@
plugins {
kotlin("jvm")
id("jps-compatible")
@@ -9,6 +8,7 @@ dependencies {
compile(project(":core:descriptors"))
compile(project(":core:deserialization"))
compile(project(":compiler:util"))
compile(project(":compiler:config"))
compile(project(":compiler:container"))
compile(project(":compiler:resolution"))
compile(project(":compiler:psi"))
compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt
-47
View File
@@ -1,47 +0,0 @@
/*
* 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
}
compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.kt
-57
View File
@@ -1,57 +0,0 @@
/*
* 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)
compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfiguration.java
-169
View File
@@ -1,169 +0,0 @@
/*
* 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++;
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfigurationKey.java
-39
View File
@@ -1,39 +0,0 @@
/*
* 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();
}
}