Make getUpperBoundsAsType an utility, remove from TypeParameterDescriptor

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java

@@ -32,14 +32,13 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolverKt;
 import org.jetbrains.kotlin.resolve.jvm.JavaResolverUtils;
-import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.kotlin.types.TypeSubstitutor;
-import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.Variance;
+import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
 import static org.jetbrains.kotlin.load.java.components.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT;
 import static org.jetbrains.kotlin.load.java.components.TypeUsage.UPPER_BOUND;
@@ -140,13 +139,16 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         for (TypeParameterDescriptor parameter : methodTypeParameters) {
             int index = parameter.getIndex();
 
-            KotlinType substituted = substitutor.substitute(parameter.getUpperBoundsAsType(), Variance.INVARIANT);
+            KotlinType upperBoundsAsType = TypeIntersector.getUpperBoundsAsType(parameter);
+            KotlinType substituted = substitutor.substitute(upperBoundsAsType, Variance.INVARIANT);
             assert substituted != null;
 
-            if (!TypeUtils.equalTypes(substituted, altTypeParameters.get(index).getUpperBoundsAsType())) {
+            KotlinType altUpperBoundsAsType = TypeIntersector.getUpperBoundsAsType(altTypeParameters.get(index));
+            if (!TypeUtils.equalTypes(substituted, altUpperBoundsAsType)) {
                 throw new AlternativeSignatureMismatchException(
                         "Type parameter's upper bound changed for method which overrides another: "
-                        + altTypeParameters.get(index).getUpperBoundsAsType() + ", was: " + parameter.getUpperBoundsAsType());
+                        + altUpperBoundsAsType + ", was: " + upperBoundsAsType
+                );
             }
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java

@@ -150,7 +150,7 @@ public class TypeTransformingVisitor extends KtVisitor<KotlinType, Void> {
 
         KtScope memberScope;
         if (typeConstructorClassifier instanceof TypeParameterDescriptor) {
-            memberScope = ((TypeParameterDescriptor) typeConstructorClassifier).getUpperBoundsAsType().getMemberScope();
+            memberScope = typeConstructorClassifier.getDefaultType().getMemberScope();
         }
         else if (typeConstructorClassifier instanceof ClassDescriptor) {
             memberScope = ((ClassDescriptor) typeConstructorClassifier).getMemberScope(altArguments);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Constrain
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.TypeIntersector
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
@@ -324,7 +325,7 @@ public object Renderers {
         }
 
         val explanation: String
-        val upperBound = typeParameterWithCapturedConstraint.getUpperBoundsAsType()
+        val upperBound = TypeIntersector.getUpperBoundsAsType(typeParameterWithCapturedConstraint)
         if (!KotlinBuiltIns.isNullableAny(upperBound) && capturedTypeConstructor.typeProjection.getProjectionKind() == Variance.IN_VARIANCE) {
             explanation = "Type parameter has an upper bound '" + result.getTypeRenderer().render(upperBound) + "'" +
                           " that cannot be satisfied capturing 'in' projection"

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -62,7 +62,8 @@ import java.util.*;
 import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.lexer.KtTokens.*;
-import static org.jetbrains.kotlin.resolve.BindingContext.*;
+import static org.jetbrains.kotlin.resolve.BindingContext.CONSTRUCTOR;
+import static org.jetbrains.kotlin.resolve.BindingContext.PACKAGE_TO_FILES;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveModalityFromModifiers;
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveVisibilityFromModifiers;
@@ -539,7 +540,7 @@ public class DescriptorResolver {
             @NotNull TypeParameterDescriptor parameter,
             @NotNull KtTypeParameter typeParameter
     ) {
-        if (KotlinBuiltIns.isNothing(parameter.getUpperBoundsAsType())) {
+        if (KotlinBuiltIns.isNothing(TypeIntersector.getUpperBoundsAsType(parameter))) {
             trace.report(CONFLICTING_UPPER_BOUNDS.on(typeParameter, parameter));
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.INCOMPATIBLE
 import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.TypeIntersector
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.oneMoreSpecificThanAnother
 
@@ -74,7 +75,7 @@ object OverloadUtil {
             val classifier = constructor.declarationDescriptor
             return when (classifier) {
                 is ClassDescriptor -> this
-                is TypeParameterDescriptor -> classifier.upperBoundsAsType
+                is TypeParameterDescriptor -> TypeIntersector.getUpperBoundsAsType(classifier)
                 else -> error("Unknown type constructor: $this")
             }
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -40,9 +40,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.Variance.INVARIANT
-import org.jetbrains.kotlin.types.Variance.IN_VARIANCE
-import org.jetbrains.kotlin.types.Variance.OUT_VARIANCE
+import org.jetbrains.kotlin.types.Variance.*
 
 public class TypeResolver(
         private val annotationResolver: AnnotationResolver,
@@ -323,12 +321,10 @@ public class TypeResolver(
     }
 
     private fun getScopeForTypeParameter(c: TypeResolutionContext, typeParameterDescriptor: TypeParameterDescriptor): KtScope {
-        if (c.checkBounds) {
-            return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope()
-        }
-        else {
-            return LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue {
-                    typeParameterDescriptor.getUpperBoundsAsType().getMemberScope()
+        return when {
+            c.checkBounds -> TypeIntersector.getUpperBoundsAsType(typeParameterDescriptor).memberScope
+            else -> LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue {
+                TypeIntersector.getUpperBoundsAsType(typeParameterDescriptor).memberScope
             })
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt

@@ -88,9 +88,9 @@ public fun CallableDescriptor.hasInferredReturnType(constraintSystem: Constraint
 
 public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): KotlinType {
     var receiverType = receiverParameterDescriptor.getType()
-    for (typeParameter in descriptor.getTypeParameters()) {
-        if (typeParameter.getTypeConstructor() == receiverType.getConstructor()) {
-            receiverType = typeParameter.getUpperBoundsAsType()
+    for (typeParameter in descriptor.typeParameters) {
+        if (typeParameter.typeConstructor == receiverType.constructor) {
+            receiverType = TypeIntersector.getUpperBoundsAsType(typeParameter)
         }
     }
     val fakeTypeArguments = ContainerUtil.newSmartList<TypeProjection>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java

@@ -77,7 +77,7 @@ public class ConstraintsUtil {
             return type;
         }
         //todo may be error type
-        return typeParameter.getUpperBoundsAsType();
+        return TypeIntersector.getUpperBoundsAsType(typeParameter);
     }
 
     public static boolean checkUpperBoundIsSatisfied(

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java

@@ -119,7 +119,6 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
         getOriginal();
         ForceResolveUtil.forceResolveAllContents(getTypeConstructor());
         ForceResolveUtil.forceResolveAllContents(getUpperBounds());
-        getUpperBoundsAsType();
         getVariance();
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java

@@ -60,7 +60,7 @@ public class BoundsSubstitutor {
 
         // todo assert: no loops
         for (TypeParameterDescriptor descriptor : topologicallySortTypeParameters(typeParameters)) {
-            KotlinType upperBoundsAsType = descriptor.getUpperBoundsAsType();
+            KotlinType upperBoundsAsType = TypeIntersector.getUpperBoundsAsType(descriptor);
             KotlinType substitutedUpperBoundsAsType = substitutor.substitute(upperBoundsAsType, Variance.INVARIANT);
             mutableSubstitution.put(descriptor.getTypeConstructor(), new TypeProjectionImpl(substitutedUpperBoundsAsType));
         }