Minor: reformat code

2018-03-16 15:22:20 +03:00
parent 26dc5840f1
commit bfcf1584a2
2 changed files with 108 additions and 105 deletions
@@ -26,13 +26,13 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*

 abstract class AbstractTypeAliasDescriptor(
-        containingDeclaration: DeclarationDescriptor,
-        annotations: Annotations,
-        name: Name,
-        sourceElement: SourceElement,
-        private val visibilityImpl: Visibility
+    containingDeclaration: DeclarationDescriptor,
+    annotations: Annotations,
+    name: Name,
+    sourceElement: SourceElement,
+    private val visibilityImpl: Visibility
 ) : DeclarationDescriptorNonRootImpl(containingDeclaration, annotations, name, sourceElement),
-        TypeAliasDescriptor {
+    TypeAliasDescriptor {

    protected abstract val storageManager: StorageManager

@@ -44,19 +44,19 @@ abstract class AbstractTypeAliasDescriptor(
    }

    override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D): R =
-            visitor.visitTypeAliasDescriptor(this, data)
+        visitor.visitTypeAliasDescriptor(this, data)

    override fun isInner(): Boolean =
-            // NB: it's ok to use underlyingType here, since referenced inner type aliases also capture type parameters.
-            // Using expandedType looks "proper", but in fact will cause a recursion in expandedType resolution,
-            // which will silently produce wrong result.
-            TypeUtils.contains(underlyingType) { type ->
-                !type.isError && run {
-                    val constructorDescriptor = type.constructor.declarationDescriptor
-                    constructorDescriptor is TypeParameterDescriptor &&
-                    constructorDescriptor.containingDeclaration != this@AbstractTypeAliasDescriptor
-                }
+        // NB: it's ok to use underlyingType here, since referenced inner type aliases also capture type parameters.
+        // Using expandedType looks "proper", but in fact will cause a recursion in expandedType resolution,
+        // which will silently produce wrong result.
+        TypeUtils.contains(underlyingType) { type ->
+            !type.isError && run {
+                val constructorDescriptor = type.constructor.declarationDescriptor
+                constructorDescriptor is TypeParameterDescriptor &&
+                        constructorDescriptor.containingDeclaration != this@AbstractTypeAliasDescriptor
            }
+        }


    fun getTypeAliasConstructors(): Collection<TypeAliasConstructorDescriptor> {
@@ -68,7 +68,7 @@ abstract class AbstractTypeAliasDescriptor(
    }

    override fun getDeclaredTypeParameters(): List<TypeParameterDescriptor> =
-            declaredTypeParametersImpl
+        declaredTypeParametersImpl

    override fun getModality() = Modality.FINAL

@@ -81,7 +81,7 @@ abstract class AbstractTypeAliasDescriptor(
    override fun isExternal() = false

    override fun getTypeConstructor(): TypeConstructor =
-            typeConstructor
+        typeConstructor

    override fun toString(): String = "typealias ${name.asString()}"

@@ -90,26 +90,26 @@ abstract class AbstractTypeAliasDescriptor(
    protected abstract fun getTypeConstructorTypeParameters(): List<TypeParameterDescriptor>

    protected fun computeDefaultType(): SimpleType =
-            TypeUtils.makeUnsubstitutedType(this, classDescriptor?.unsubstitutedMemberScope ?: MemberScope.Empty)
+        TypeUtils.makeUnsubstitutedType(this, classDescriptor?.unsubstitutedMemberScope ?: MemberScope.Empty)

    private val typeConstructor = object : TypeConstructor {
        override fun getDeclarationDescriptor(): TypeAliasDescriptor =
-                this@AbstractTypeAliasDescriptor
+            this@AbstractTypeAliasDescriptor

        override fun getParameters(): List<TypeParameterDescriptor> =
-                getTypeConstructorTypeParameters()
+            getTypeConstructorTypeParameters()

        override fun getSupertypes(): Collection<KotlinType> =
-                declarationDescriptor.underlyingType.constructor.supertypes
+            declarationDescriptor.underlyingType.constructor.supertypes

        override fun isFinal(): Boolean =
-                declarationDescriptor.underlyingType.constructor.isFinal
+            declarationDescriptor.underlyingType.constructor.isFinal

        override fun isDenotable(): Boolean =
-                true
+            true

        override fun getBuiltIns(): KotlinBuiltIns =
-                declarationDescriptor.builtIns
+            declarationDescriptor.builtIns

        override fun toString(): String = "[typealias ${declarationDescriptor.name.asString()}]"
    }
@@ -38,25 +38,25 @@ interface TypeAliasConstructorDescriptor : ConstructorDescriptor, DescriptorDeri
    val withDispatchReceiver: TypeAliasConstructorDescriptor?

    override fun copy(
-            newOwner: DeclarationDescriptor,
-            modality: Modality,
-            visibility: Visibility,
-            kind: Kind,
-            copyOverrides: Boolean
+        newOwner: DeclarationDescriptor,
+        modality: Modality,
+        visibility: Visibility,
+        kind: Kind,
+        copyOverrides: Boolean
    ): TypeAliasConstructorDescriptor
 }

 class TypeAliasConstructorDescriptorImpl private constructor(
-        val storageManager: StorageManager,
-        override val typeAliasDescriptor: TypeAliasDescriptor,
-        underlyingConstructorDescriptor: ClassConstructorDescriptor,
-        original: TypeAliasConstructorDescriptor?,
-        annotations: Annotations,
-        kind: Kind,
-        source: SourceElement
+    val storageManager: StorageManager,
+    override val typeAliasDescriptor: TypeAliasDescriptor,
+    underlyingConstructorDescriptor: ClassConstructorDescriptor,
+    original: TypeAliasConstructorDescriptor?,
+    annotations: Annotations,
+    kind: Kind,
+    source: SourceElement
 ) : TypeAliasConstructorDescriptor,
-        FunctionDescriptorImpl(typeAliasDescriptor, original, annotations, Name.special("<init>"), kind, source)
-{
+    FunctionDescriptorImpl(typeAliasDescriptor, original, annotations, Name.special("<init>"), kind, source) {
+
    init {
        isActual = typeAliasDescriptor.isActual
    }
@@ -67,46 +67,46 @@ class TypeAliasConstructorDescriptorImpl private constructor(
    // a dispatch receiver
    override val withDispatchReceiver: TypeAliasConstructorDescriptor? by storageManager.createNullableLazyValue {
        TypeAliasConstructorDescriptorImpl(
-                storageManager,
-                typeAliasDescriptor,
-                underlyingConstructorDescriptor,
-                this,
-                underlyingConstructorDescriptor.annotations,
-                underlyingConstructorDescriptor.kind,
-                typeAliasDescriptor.source
+            storageManager,
+            typeAliasDescriptor,
+            underlyingConstructorDescriptor,
+            this,
+            underlyingConstructorDescriptor.annotations,
+            underlyingConstructorDescriptor.kind,
+            typeAliasDescriptor.source
        ).also { typeAliasConstructor ->
-            val substitutorForUnderlyingClass = typeAliasDescriptor.getTypeSubstitutorForUnderlyingClass() ?:
-                                                return@createNullableLazyValue null
+            val substitutorForUnderlyingClass =
+                typeAliasDescriptor.getTypeSubstitutorForUnderlyingClass() ?: return@createNullableLazyValue null

            typeAliasConstructor.initialize(
-                    null,
-                    underlyingConstructorDescriptor.dispatchReceiverParameter?.substitute(substitutorForUnderlyingClass),
-                    typeAliasDescriptor.declaredTypeParameters,
-                    valueParameters,
-                    returnType,
-                    Modality.FINAL,
-                    typeAliasDescriptor.visibility
+                null,
+                underlyingConstructorDescriptor.dispatchReceiverParameter?.substitute(substitutorForUnderlyingClass),
+                typeAliasDescriptor.declaredTypeParameters,
+                valueParameters,
+                returnType,
+                Modality.FINAL,
+                typeAliasDescriptor.visibility
            )
        }
    }

    override var underlyingConstructorDescriptor: ClassConstructorDescriptor = underlyingConstructorDescriptor
-            private set
+        private set

    override fun isPrimary(): Boolean =
-            underlyingConstructorDescriptor.isPrimary
+        underlyingConstructorDescriptor.isPrimary

    override fun getContainingDeclaration(): TypeAliasDescriptor =
-            typeAliasDescriptor
+        typeAliasDescriptor

    override fun getConstructedClass(): ClassDescriptor =
-            underlyingConstructorDescriptor.constructedClass
+        underlyingConstructorDescriptor.constructedClass

    override fun getReturnType(): KotlinType =
-            super.getReturnType()!!
+        super.getReturnType()!!

    override fun getOriginal(): TypeAliasConstructorDescriptor =
-            super.getOriginal() as TypeAliasConstructorDescriptor
+        super.getOriginal() as TypeAliasConstructorDescriptor

    override fun substitute(substitutor: TypeSubstitutor): TypeAliasConstructorDescriptor? {
        //    class C<T>(val x: T)
@@ -121,45 +121,46 @@ class TypeAliasConstructorDescriptorImpl private constructor(
        val substitutedTypeAliasConstructor = super.substitute(substitutor) as TypeAliasConstructorDescriptorImpl
        val underlyingConstructorSubstitutor = TypeSubstitutor.create(substitutedTypeAliasConstructor.returnType)
        val substitutedUnderlyingConstructor = underlyingConstructorDescriptor.original.substitute(underlyingConstructorSubstitutor)
-                                               ?: return null
+                ?: return null
        substitutedTypeAliasConstructor.underlyingConstructorDescriptor = substitutedUnderlyingConstructor
        return substitutedTypeAliasConstructor
    }

    override fun copy(
-            newOwner: DeclarationDescriptor,
-            modality: Modality,
-            visibility: Visibility,
-            kind: Kind,
-            copyOverrides: Boolean
+        newOwner: DeclarationDescriptor,
+        modality: Modality,
+        visibility: Visibility,
+        kind: Kind,
+        copyOverrides: Boolean
    ): TypeAliasConstructorDescriptor =
-            newCopyBuilder()
-                    .setOwner(newOwner)
-                    .setModality(modality)
-                    .setVisibility(visibility)
-                    .setKind(kind)
-                    .setCopyOverrides(copyOverrides)
-                    .build() as TypeAliasConstructorDescriptor
+        newCopyBuilder()
+            .setOwner(newOwner)
+            .setModality(modality)
+            .setVisibility(visibility)
+            .setKind(kind)
+            .setCopyOverrides(copyOverrides)
+            .build() as TypeAliasConstructorDescriptor

    override fun createSubstitutedCopy(
-            newOwner: DeclarationDescriptor,
-            original: FunctionDescriptor?,
-            kind: Kind,
-            newName: Name?,
-            annotations: Annotations,
-            source: SourceElement
+        newOwner: DeclarationDescriptor,
+        original: FunctionDescriptor?,
+        kind: Kind,
+        newName: Name?,
+        annotations: Annotations,
+        source: SourceElement
    ): TypeAliasConstructorDescriptorImpl {
        assert(kind == Kind.DECLARATION || kind == Kind.SYNTHESIZED) {
            "Creating a type alias constructor that is not a declaration: \ncopy from: ${this}\nnewOwner: $newOwner\nkind: $kind"
        }
        assert(newName == null) { "Renaming type alias constructor: $this" }
        return TypeAliasConstructorDescriptorImpl(
-                storageManager,
-                typeAliasDescriptor,
-                underlyingConstructorDescriptor,
-                this,
-                annotations,
-                Kind.DECLARATION, source)
+            storageManager,
+            typeAliasDescriptor,
+            underlyingConstructorDescriptor,
+            this,
+            annotations,
+            Kind.DECLARATION, source
+        )
    }

    companion object {
@@ -169,39 +170,41 @@ class TypeAliasConstructorDescriptorImpl private constructor(
        }

        fun createIfAvailable(
-                storageManager: StorageManager,
-                typeAliasDescriptor: TypeAliasDescriptor,
-                constructor: ClassConstructorDescriptor
+            storageManager: StorageManager,
+            typeAliasDescriptor: TypeAliasDescriptor,
+            constructor: ClassConstructorDescriptor
        ): TypeAliasConstructorDescriptor? {
            val substitutorForUnderlyingClass = typeAliasDescriptor.getTypeSubstitutorForUnderlyingClass() ?: return null

            val typeAliasConstructor =
-                    TypeAliasConstructorDescriptorImpl(
-                            storageManager, typeAliasDescriptor, constructor, null, constructor.annotations,
-                            constructor.kind, typeAliasDescriptor.source)
+                TypeAliasConstructorDescriptorImpl(
+                    storageManager, typeAliasDescriptor, constructor, null, constructor.annotations,
+                    constructor.kind, typeAliasDescriptor.source
+                )

            val valueParameters =
-                    FunctionDescriptorImpl.getSubstitutedValueParameters(
-                            typeAliasConstructor, constructor.valueParameters, substitutorForUnderlyingClass, false, false,
-                            null
-                    ) ?: return null
+                FunctionDescriptorImpl.getSubstitutedValueParameters(
+                    typeAliasConstructor, constructor.valueParameters, substitutorForUnderlyingClass, false, false,
+                    null
+                ) ?: return null

            val returnType = run {
                val returnTypeNoAbbreviation = substitutorForUnderlyingClass.substitute(constructor.returnType, Variance.INVARIANT)
-                                               ?: return null
+                        ?: return null
                returnTypeNoAbbreviation.unwrap().lowerIfFlexible().withAbbreviation(typeAliasDescriptor.defaultType)
            }

-            val receiverParameterType = constructor.dispatchReceiverParameter?.let { substitutorForUnderlyingClass.safeSubstitute(it.type, Variance.INVARIANT) }
+            val receiverParameterType =
+                constructor.dispatchReceiverParameter?.let { substitutorForUnderlyingClass.safeSubstitute(it.type, Variance.INVARIANT) }

            typeAliasConstructor.initialize(
-                    receiverParameterType,
-                    null,
-                    typeAliasDescriptor.declaredTypeParameters,
-                    valueParameters,
-                    returnType,
-                    Modality.FINAL,
-                    typeAliasDescriptor.visibility
+                receiverParameterType,
+                null,
+                typeAliasDescriptor.declaredTypeParameters,
+                valueParameters,
+                returnType,
+                Modality.FINAL,
+                typeAliasDescriptor.visibility
            )

            return typeAliasConstructor