From 53bf720503c0e605d71d7f6219664957fab734fd Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Thu, 9 Jun 2016 15:51:34 +0300 Subject: [PATCH] Fix type alias problems after rebase. --- .../kotlin/resolve/DescriptorResolver.java | 7 +++--- .../jetbrains/kotlin/resolve/TypeResolver.kt | 25 ++++++++----------- .../serialization/DescriptorSerializer.kt | 15 +++++------ .../typeAliasShouldExpandToClass.txt | 12 ++++----- .../typealiasExpandingToDynamic.kt | 6 ++--- .../typealiasExpandingToDynamic.txt | 2 +- 6 files changed, 32 insertions(+), 35 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index fd607e4704e..f32231910bd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -725,7 +725,7 @@ public class DescriptorResolver { ErrorUtils.createErrorType(name.asString())); } else if (!languageFeatureSettings.supportsFeature(LanguageFeature.TypeAliases)) { - typeResolver.resolveAbbreviatedType(scopeWithTypeParameters, typeReference, trace, true); + typeResolver.resolveAbbreviatedType(scopeWithTypeParameters, typeReference, trace); PsiElement typeAliasKeyword = typeAlias.getTypeAliasKeyword(); trace.report(UNSUPPORTED_TYPEALIAS.on(typeAliasKeyword != null ? typeAliasKeyword : typeAlias)); typeAliasDescriptor.initialize( @@ -739,14 +739,13 @@ public class DescriptorResolver { storageManager.createLazyValue(new Function0() { @Override public SimpleType invoke() { - return typeResolver.resolveAbbreviatedType(scopeWithTypeParameters, typeReference, trace, true); + return typeResolver.resolveAbbreviatedType(scopeWithTypeParameters, typeReference, trace); } }), storageManager.createLazyValue(new Function0() { @Override public SimpleType invoke() { - // TODO do not reparse - return typeResolver.resolveAbbreviatedType(scopeWithTypeParameters, typeReference, trace, false); + return typeResolver.resolveExpandedTypeForTypeAlias(typeAliasDescriptor); } })); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt index aa91603049d..dc9cf622874 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt @@ -71,23 +71,20 @@ class TypeResolver( return resolveType(TypeResolutionContext(scope, trace, checkBounds, false, typeReference.suppressDiagnosticsInDebugMode(), false), typeReference) } - fun resolveAbbreviatedType(scope: LexicalScope, typeReference: KtTypeReference, trace: BindingTrace, abbreviated: Boolean): SimpleType { - return resolveSimpleType( - TypeResolutionContext(scope, trace, true, false, typeReference.suppressDiagnosticsInDebugMode(), abbreviated), - typeReference - ) - } - - private fun resolveSimpleType(c: TypeResolutionContext, typeReference: KtTypeReference): SimpleType { - val unwrappedType = resolveType(c, typeReference).unwrap() - return when (unwrappedType) { - is DynamicType -> ErrorUtils.createErrorType("dynamic type in wrong context") - is SimpleType -> unwrappedType - else -> error("Unexpected type: $unwrappedType") + fun resolveAbbreviatedType(scope: LexicalScope, typeReference: KtTypeReference, trace: BindingTrace): SimpleType { + val resolvedType = resolveType(TypeResolutionContext(scope, trace, true, false, typeReference.suppressDiagnosticsInDebugMode(), true), + typeReference).unwrap() + return when (resolvedType) { + is DynamicType -> { + trace.report(Errors.TYPEALIAS_SHOULD_EXPAND_TO_CLASS.on(typeReference, resolvedType)) + ErrorUtils.createErrorType("dynamic type in wrong context") + } + is SimpleType -> resolvedType + else -> error("Unexpected type: $resolvedType") } } - fun resolveExpandedTypeForTypeAlias(typeAliasDescriptor: TypeAliasDescriptor): KotlinType { + fun resolveExpandedTypeForTypeAlias(typeAliasDescriptor: TypeAliasDescriptor): SimpleType { val typeAliasExpansion = TypeAliasExpansion.createWithFormalArguments(typeAliasDescriptor) val expandedType = TypeAliasExpander.NON_REPORTING.expandWithoutAbbreviation(typeAliasExpansion, Annotations.EMPTY) return expandedType diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index 730c5130128..cdec7865cc7 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt @@ -44,8 +44,8 @@ class DescriptorSerializer private constructor( }.toByteArray() } - private fun createChildSerializer(callable: CallableDescriptor): DescriptorSerializer = - DescriptorSerializer(callable, Interner(typeParameters), extension, typeTable, serializeTypeTableToFunction = false) + private fun createChildSerializer(descriptor: DeclarationDescriptor): DescriptorSerializer = + DescriptorSerializer(descriptor, Interner(typeParameters), extension, typeTable, serializeTypeTableToFunction = false) val stringTable: StringTable get() = extension.stringTable @@ -277,6 +277,7 @@ class DescriptorSerializer private constructor( fun typeAliasProto(descriptor: TypeAliasDescriptor): ProtoBuf.TypeAlias.Builder { val builder = ProtoBuf.TypeAlias.newBuilder() + val local = createChildSerializer(descriptor) val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), descriptor.visibility) if (flags != builder.flags) { @@ -286,23 +287,23 @@ class DescriptorSerializer private constructor( builder.name = getSimpleNameIndex(descriptor.name) for (typeParameterDescriptor in descriptor.declaredTypeParameters) { - builder.addTypeParameter(typeParameter(typeParameterDescriptor)) + builder.addTypeParameter(local.typeParameter(typeParameterDescriptor)) } val underlyingType = descriptor.underlyingType if (useTypeTable()) { - builder.underlyingTypeId = typeId(underlyingType) + builder.underlyingTypeId = local.typeId(underlyingType) } else { - builder.setUnderlyingType(type(underlyingType)) + builder.setUnderlyingType(local.type(underlyingType)) } val expandedType = descriptor.expandedType if (useTypeTable()) { - builder.expandedTypeId = typeId(expandedType) + builder.expandedTypeId = local.typeId(expandedType) } else { - builder.setExpandedType(type(expandedType)) + builder.setExpandedType(local.type(expandedType)) } return builder diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.txt b/compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.txt index ac30d89cd2f..51c73fefa46 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.txt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.txt @@ -3,15 +3,15 @@ package public typealias ToFun1 = () -> kotlin.Unit public typealias ToFun2 = (T) -> kotlin.Unit public typealias ToTypeParam1 = T -public typealias ToTypeParam2 = ToTypeParam1 [= T] -public typealias ToTypeParam3 = ToTypeParam2 [= T1] -public typealias ToTypeParam4 = ToTypeParam1 [= kotlin.Any] +public typealias ToTypeParam2 = ToTypeParam1 +public typealias ToTypeParam3 = ToTypeParam2 +public typealias ToTypeParam4 = ToTypeParam1 public final class Outer { public typealias ToTypeParam1 = T - public typealias ToTypeParam2 = Outer.ToTypeParam1 [= T] - public typealias ToTypeParam3 = Outer.ToTypeParam2 [= T1] - public typealias ToTypeParam4 = Outer.ToTypeParam1 [= kotlin.Any] + public typealias ToTypeParam2 = Outer.ToTypeParam1 + public typealias ToTypeParam3 = Outer.ToTypeParam2 + public typealias ToTypeParam4 = Outer.ToTypeParam1 public constructor Outer() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.kt index 53fae665c78..a68e6ca1793 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.kt @@ -1,6 +1,6 @@ typealias Dyn = dynamic -typealias Dyn2 = Dyn -typealias Dyn3 = Dyn2 +typealias Dyn2 = Dyn +typealias Dyn3 = Dyn2 typealias Type = T -typealias Dyn4 = Type +typealias Dyn4 = Type diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.txt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.txt index 4b10ad99292..f1cd7cb37b8 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.txt @@ -1,6 +1,6 @@ package -public typealias Dyn = dynamic +public typealias Dyn = [ERROR : dynamic type in wrong context] public typealias Dyn2 = Dyn public typealias Dyn3 = Dyn2 public typealias Dyn4 = Type