Some progress
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CollectionLiteralResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CollectionLiteralResolver.kt
index 6502466..51bfb98 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CollectionLiteralResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CollectionLiteralResolver.kt
@@ -127,10 +127,12 @@
return ArrayFqNames.ARRAY_OF_FUNCTION
}
+ val primitiveElementType = KotlinBuiltIns.getPrimitiveArrayElementType(expectedType)
+ if (primitiveElementType != null) return ArrayFqNames.PRIMITIVE_TYPE_TO_ARRAY[primitiveElementType]!!
+
val descriptor = expectedType.constructor.declarationDescriptor ?: return ArrayFqNames.ARRAY_OF_FUNCTION
- return ArrayFqNames.PRIMITIVE_TYPE_TO_ARRAY[KotlinBuiltIns.getPrimitiveArrayType(descriptor)]
- ?: UnsignedTypes.unsignedArrayTypeToArrayCall[UnsignedTypes.toUnsignedArrayType(descriptor)]
+ return UnsignedTypes.unsignedArrayTypeToArrayCall[UnsignedTypes.toUnsignedArrayType(descriptor)]
?: ArrayFqNames.ARRAY_OF_FUNCTION
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
index cb02751..1b0347d 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
@@ -51,7 +51,6 @@
get() = symbolTable
val iterator = getClass(Name.identifier("Iterator"), "kotlin", "collections")
- val vArrayIterator = getClass(Name.identifier("VArrayIterator"), "kotlin")
val charSequence = getClass(Name.identifier("CharSequence"), "kotlin")
val string = getClass(Name.identifier("String"), "kotlin")
@@ -134,14 +133,17 @@
val doubleArray get() = irBuiltIns.doubleArray
val booleanArray get() = irBuiltIns.booleanArray
- val byteArrayType get() = byteArray.owner.defaultType
- val charArrayType get() = charArray.owner.defaultType
- val shortArrayType get() = shortArray.owner.defaultType
- val intArrayType get() = intArray.owner.defaultType
- val longArrayType get() = longArray.owner.defaultType
- val floatArrayType get() = floatArray.owner.defaultType
- val doubleArrayType get() = doubleArray.owner.defaultType
- val booleanArrayType get() = booleanArray.owner.defaultType
+ val byteArrayType get() = primitiveArrayType(irBuiltIns.byteType, irBuiltIns.byteArray)
+ val charArrayType get() = primitiveArrayType(irBuiltIns.charType, irBuiltIns.charArray)
+ val shortArrayType get() = primitiveArrayType(irBuiltIns.shortType, irBuiltIns.shortArray)
+ val intArrayType get() = primitiveArrayType(irBuiltIns.intType, irBuiltIns.intArray)
+ val longArrayType get() = primitiveArrayType(irBuiltIns.longType, irBuiltIns.longArray)
+ val floatArrayType get() = primitiveArrayType(irBuiltIns.floatType, irBuiltIns.floatArray)
+ val doubleArrayType get() = primitiveArrayType(irBuiltIns.doubleType, irBuiltIns.doubleArray)
+ val booleanArrayType get() = primitiveArrayType(irBuiltIns.booleanType, irBuiltIns.booleanArray)
+
+ private fun primitiveArrayType(elementType: IrType, arrayClass: IrClassSymbol?) =
+ arrayClass?.owner?.defaultType ?: vArray!!.typeWith(elementType)
val primitiveTypesToPrimitiveArrays get() = irBuiltIns.primitiveTypesToPrimitiveArrays
val primitiveArraysToPrimitiveTypes get() = irBuiltIns.primitiveArraysToPrimitiveTypes
diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
index bd3cbde..df10dbb 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
@@ -61,6 +61,7 @@
Key(kotlinFqn, null, "enumValueOf", listOf(stringFqn)) to EnumValueOf,
Key(kotlinFqn, stringFqn, "plus", listOf(anyFqn)) to StringPlus,
Key(kotlinReflectFqn, null, "typeOf", listOf()) to TypeOf,
+ Key(StandardNames.FqNames.vArrayIterator.toSafe(), null, "next", listOf()) to VArrayIteratorNext,
irBuiltIns.eqeqSymbol.toKey()!! to Equals(KtTokens.EQEQ),
irBuiltIns.eqeqeqSymbol.toKey()!! to Equals(KtTokens.EQEQEQ),
irBuiltIns.ieee754equalsFunByOperandType[irBuiltIns.floatClass]!!.toKey()!! to Ieee754Equals(Type.FLOAT_TYPE),
@@ -85,7 +86,6 @@
symbols.jvmDebuggerInvokeSpecialIntrinsic.toKey()!! to JvmDebuggerInvokeSpecial,
symbols.intPostfixIncrDecr.toKey()!! to IntIncr(isPrefix = false),
symbols.intPrefixIncrDecr.toKey()!! to IntIncr(isPrefix = true),
- createKeyMapping(VArrayIteratorNext, symbols.vArrayIterator, "next"),
) +
numberConversionMethods() +
unaryFunForPrimitives("plus", UnaryPlus) +
diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
index 9e850c7..d956d98 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
@@ -375,14 +375,14 @@
override val primitiveIrTypesWithComparisons = listOf(charType, byteType, shortType, intType, floatType, longType, doubleType)
override val primitiveFloatingPointIrTypes = listOf(floatType, doubleType)
- override val byteArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BYTE).toIrSymbol()
- override val charArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.CHAR).toIrSymbol()
- override val shortArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.SHORT).toIrSymbol()
- override val intArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.INT).toIrSymbol()
- override val longArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.LONG).toIrSymbol()
- override val floatArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.FLOAT).toIrSymbol()
- override val doubleArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.DOUBLE).toIrSymbol()
- override val booleanArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BOOLEAN).toIrSymbol()
+ override val byteArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BYTE)?.toIrSymbol()
+ override val charArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.CHAR)?.toIrSymbol()
+ override val shortArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.SHORT)?.toIrSymbol()
+ override val intArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.INT)?.toIrSymbol()
+ override val longArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.LONG)?.toIrSymbol()
+ override val floatArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.FLOAT)?.toIrSymbol()
+ override val doubleArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.DOUBLE)?.toIrSymbol()
+ override val booleanArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BOOLEAN)?.toIrSymbol()
override val primitiveArraysToPrimitiveTypes =
PrimitiveType.values().associate { builtIns.getPrimitiveArrayClassDescriptor(it).toIrSymbol() to it }
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
index 24e90199..74911d3 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
@@ -101,14 +101,14 @@
abstract val primitiveIrTypesWithComparisons: List<IrType>
abstract val primitiveFloatingPointIrTypes: List<IrType>
- abstract val byteArray: IrClassSymbol
- abstract val charArray: IrClassSymbol
- abstract val shortArray: IrClassSymbol
- abstract val intArray: IrClassSymbol
- abstract val longArray: IrClassSymbol
- abstract val floatArray: IrClassSymbol
- abstract val doubleArray: IrClassSymbol
- abstract val booleanArray: IrClassSymbol
+ abstract val byteArray: IrClassSymbol?
+ abstract val charArray: IrClassSymbol?
+ abstract val shortArray: IrClassSymbol?
+ abstract val intArray: IrClassSymbol?
+ abstract val longArray: IrClassSymbol?
+ abstract val floatArray: IrClassSymbol?
+ abstract val doubleArray: IrClassSymbol?
+ abstract val booleanArray: IrClassSymbol?
abstract val primitiveArraysToPrimitiveTypes: Map<IrClassSymbol, PrimitiveType>
abstract val primitiveTypesToPrimitiveArrays: Map<PrimitiveType, IrClassSymbol>
diff --git a/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt b/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt
index 887f80a..78303e2 100644
--- a/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt
+++ b/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt
@@ -97,6 +97,7 @@
@JvmField val string: FqNameUnsafe = fqNameUnsafe("String")
@JvmField val array: FqNameUnsafe = fqNameUnsafe("Array")
@JvmField val vArray: FqNameUnsafe = fqNameUnsafe("VArray")
+ @JvmField val vArrayIterator : FqNameUnsafe = fqNameUnsafe("VArrayIterator")
@JvmField val _boolean: FqNameUnsafe = fqNameUnsafe("Boolean")
@JvmField val _char: FqNameUnsafe = fqNameUnsafe("Char")
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
index ef28949..b752aa3 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
@@ -26,6 +26,7 @@
import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
import org.jetbrains.kotlin.resolve.scopes.MemberScope;
import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
+import org.jetbrains.kotlin.storage.MemoizedFunctionToNullable;
import org.jetbrains.kotlin.storage.NotNullLazyValue;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.types.*;
@@ -44,7 +45,7 @@
private final NotNullLazyValue<Primitives> primitives;
private final NotNullLazyValue<Collection<PackageViewDescriptor>> builtInPackagesImportedByDefault;
- private final MemoizedFunctionToNotNull<Name, ClassDescriptor> builtInClassesByName;
+ private final MemoizedFunctionToNullable<Name, ClassifierDescriptor> builtInClassifiersByName;
private final StorageManager storageManager;
@@ -57,10 +58,10 @@
@Override
public Collection<PackageViewDescriptor> invoke() {
return Arrays.asList(
- getBuiltInsModule().getPackage(BUILT_INS_PACKAGE_FQ_NAME),
- getBuiltInsModule().getPackage(COLLECTIONS_PACKAGE_FQ_NAME),
- getBuiltInsModule().getPackage(RANGES_PACKAGE_FQ_NAME),
- getBuiltInsModule().getPackage(ANNOTATION_PACKAGE_FQ_NAME)
+ getBuiltInsModule().getPackage(BUILT_INS_PACKAGE_FQ_NAME),
+ getBuiltInsModule().getPackage(COLLECTIONS_PACKAGE_FQ_NAME),
+ getBuiltInsModule().getPackage(RANGES_PACKAGE_FQ_NAME),
+ getBuiltInsModule().getPackage(ANNOTATION_PACKAGE_FQ_NAME)
);
}
});
@@ -73,7 +74,7 @@
Map<SimpleType, SimpleType> kotlinArrayTypeToPrimitiveKotlinType = new HashMap<SimpleType, SimpleType>();
for (PrimitiveType primitive : PrimitiveType.values()) {
SimpleType type = getBuiltInTypeByClassName(primitive.getTypeName().asString());
- SimpleType arrayType = getBuiltInTypeByClassName(primitive.getArrayTypeName().asString());
+ SimpleType arrayType = getBuiltInArrayType(primitive);
primitiveTypeToArrayKotlinType.put(primitive, arrayType);
primitiveKotlinTypeToKotlinArrayType.put(type, arrayType);
@@ -85,16 +86,13 @@
}
});
- this.builtInClassesByName = storageManager.createMemoizedFunction(new Function1<Name, ClassDescriptor>() {
- @Override
- public ClassDescriptor invoke(Name name) {
- ClassifierDescriptor classifier = getBuiltInsPackageScope().getContributedClassifier(name, NoLookupLocation.FROM_BUILTINS);
- if (classifier != null && !(classifier instanceof ClassDescriptor)) {
- throw new AssertionError("Must be a class descriptor " + name + ", but was " + classifier);
- }
- return (ClassDescriptor) classifier;
- }
- });
+ this.builtInClassifiersByName =
+ storageManager.createMemoizedFunctionWithNullableValues(new Function1<Name, ClassifierDescriptor>() {
+ @Override
+ public ClassifierDescriptor invoke(Name name) {
+ return getBuiltInsPackageScope().getContributedClassifier(name, NoLookupLocation.FROM_BUILTINS);
+ }
+ });
}
protected void createBuiltInsModule(boolean isFallback) {
@@ -179,7 +177,7 @@
/**
* Checks if the given descriptor is declared in the deserialized built-in package fragment, i.e. if it was loaded as a part of
* loading .kotlin_builtins definition files.
- *
+ * <p>
* NOTE: this method returns false for descriptors loaded from .class files or other binaries, even if they are "built-in" in some
* other sense! For example, it returns false for the class descriptor of `kotlin.IntRange` loaded from `kotlin/IntRange.class`.
* In case you need to check if the class is "built-in" in another sense, you should probably do it by inspecting its FQ name,
@@ -217,15 +215,35 @@
@NotNull
private ClassDescriptor getBuiltInClassByName(@NotNull String simpleName) {
- ClassDescriptor classDescriptor = builtInClassesByName.invoke(Name.identifier(simpleName));
- if (classDescriptor == null) {
+ ClassDescriptor descriptor = getBuiltInClassByNameOrNull(simpleName);
+ if (descriptor == null) {
throw new AssertionError("Built-in class " + BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(simpleName)) + " is not found");
}
- return classDescriptor;
+ return descriptor;
+ }
+
+ @NotNull
+ private SimpleType getBuiltInArrayType(@NotNull PrimitiveType primitive) {
+ ClassifierDescriptor arrayClassifier = builtInClassifiersByName.invoke(Name.identifier(primitive.getArrayTypeName().asString()));
+ SimpleType arrayType;
+ if (arrayClassifier instanceof ClassDescriptor) {
+ arrayType = arrayClassifier.getDefaultType();
+ }
+ else if (arrayClassifier instanceof TypeAliasDescriptor) {
+ arrayType = ((TypeAliasDescriptor) arrayClassifier).getExpandedType();
+ }
+ else {
+ throw new AssertionError("Unsupported array type classifier for " + primitive + ": " + arrayClassifier);
+ }
+ return arrayType;
}
private ClassDescriptor getBuiltInClassByNameOrNull(@NotNull String simpleName) {
- return builtInClassesByName.invoke(Name.identifier(simpleName));
+ ClassifierDescriptor classifier = builtInClassifiersByName.invoke(Name.identifier(simpleName));
+ if (classifier != null && !(classifier instanceof ClassDescriptor)) {
+ throw new AssertionError("Must be a class descriptor " + simpleName + ", but was " + classifier);
+ }
+ return (ClassDescriptor) classifier;
}
@NotNull
@@ -292,9 +310,8 @@
return getBuiltInClassByNameOrNull("VArray");
}
- @NotNull
public ClassDescriptor getPrimitiveArrayClassDescriptor(@NotNull PrimitiveType type) {
- return getBuiltInClassByName(type.getArrayTypeName().asString());
+ return getBuiltInClassByNameOrNull(type.getArrayTypeName().asString());
}
@NotNull
@@ -472,7 +489,8 @@
@NotNull
public ClassDescriptor getMutableMapEntry() {
- ClassDescriptor classDescriptor = DescriptorUtils.getInnerClassByName(getMutableMap(), "MutableEntry", NoLookupLocation.FROM_BUILTINS);
+ ClassDescriptor classDescriptor =
+ DescriptorUtils.getInnerClassByName(getMutableMap(), "MutableEntry", NoLookupLocation.FROM_BUILTINS);
assert classDescriptor != null : "Can't find MutableMap.MutableEntry";
return classDescriptor;
}
@@ -584,7 +602,7 @@
@NotNull
public KotlinType getArrayElementType(@NotNull KotlinType arrayType) {
- if (isArray(arrayType)) {
+ if (isArray(arrayType) || isVArray(arrayType)) {
if (arrayType.getArguments().size() != 1) {
throw new IllegalStateException();
}
@@ -671,6 +689,16 @@
: null;
}
+ @Nullable
+ public static PrimitiveType getPrimitiveArrayElementType(@NotNull KotlinType type) {
+ if (isPrimitiveVArray(type)) {
+ Name primitiveTypeName =
+ type.getArguments().get(0).getType().getConstructor().getDeclarationDescriptor().getName();
+ return FqNames.fqNameToPrimitiveType.get(BUILT_INS_PACKAGE_FQ_NAME.child(primitiveTypeName).toUnsafe());
+ }
+ return getPrimitiveArrayType(type.getConstructor().getDeclarationDescriptor());
+ }
+
@NotNull
public SimpleType getArrayType(@NotNull Variance projectionType, @NotNull KotlinType argument, @NotNull Annotations annotations) {
List<TypeProjectionImpl> types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument));
@@ -713,15 +741,18 @@
return isArray(type) || isPrimitiveArray(type);
}
- public static boolean isPrimitiveArray(@NotNull KotlinType type) {
- ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
- return descriptor != null && getPrimitiveArrayType(descriptor) != null;
+ public static boolean isPrimitiveVArray(@NotNull KotlinType type) {
+ if (isVArray(type)) {
+ TypeProjection elementType = type.getArguments().get(0);
+ return elementType.getProjectionKind() == Variance.INVARIANT && isPrimitiveType(elementType.getType());
+ }
+ return false;
}
- @Nullable
- public static PrimitiveType getPrimitiveArrayElementType(@NotNull KotlinType type) {
+ public static boolean isPrimitiveArray(@NotNull KotlinType type) {
+ if (isPrimitiveVArray(type)) return true;
ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
- return descriptor == null ? null : getPrimitiveArrayType(descriptor);
+ return descriptor != null && getPrimitiveArrayType(descriptor) != null;
}
@Nullable
@@ -917,8 +948,9 @@
assert functionReturnType != null : "Function return typed type must be resolved.";
boolean mayReturnNonUnitValue = !isUnit(functionReturnType);
for (FunctionDescriptor overriddenDescriptor : descriptor.getOriginal().getOverriddenDescriptors()) {
- if (mayReturnNonUnitValue)
+ if (mayReturnNonUnitValue) {
break;
+ }
KotlinType overriddenFunctionReturnType = overriddenDescriptor.getReturnType();
assert overriddenFunctionReturnType != null : "Function return typed type must be resolved.";
mayReturnNonUnitValue = !isUnit(overriddenFunctionReturnType);
