Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.types;
import kotlin.KotlinPackage;
import kotlin.jvm.functions.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.types.checker.JetTypeChecker;
import org.jetbrains.kotlin.types.typeUtil.TypeUtilPackage;
import java.util.*;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns;
import static org.jetbrains.kotlin.types.TypeUtils.topologicallySortSuperclassesAndRecordAllInstances;
import static org.jetbrains.kotlin.types.Variance.IN_VARIANCE;
import static org.jetbrains.kotlin.types.Variance.OUT_VARIANCE;
public class CommonSupertypes {
@Nullable
public static JetType commonSupertypeForNonDenotableTypes(@NotNull Collection types) {
if (types.isEmpty()) return null;
if (types.size() == 1) {
JetType type = types.iterator().next();
if (type.getConstructor() instanceof IntersectionTypeConstructor) {
return commonSupertypeForNonDenotableTypes(type.getConstructor().getSupertypes());
}
}
return commonSupertype(types);
}
@NotNull
public static JetType commonSupertype(@NotNull Collection types) {
// Recursion should not be significantly deeper than the deepest type in question
// It can be slightly deeper, though: e.g. when initial types are simple, but their supertypes are complex
return findCommonSupertype(types, 0, maxDepth(types) + 3);
}
private static int maxDepth(@NotNull Collection types) {
int max = 0;
for (JetType type : types) {
int depth = depth(type);
if (max < depth) {
max = depth;
}
}
return max;
}
private static int depth(@NotNull JetType type) {
return 1 + maxDepth(KotlinPackage.map(type.getArguments(), new Function1() {
@Override
public JetType invoke(TypeProjection projection) {
if (projection.isStarProjection()) {
// any type is good enough for depth here
return KotlinBuiltIns.getInstance().getAnyType();
}
return projection.getType();
}
}));
}
@NotNull
private static JetType findCommonSupertype(@NotNull Collection types, int recursionDepth, int maxDepth) {
assert recursionDepth <= maxDepth : "Recursion depth exceeded: " + recursionDepth + " > " + maxDepth + " for types " + types;
boolean hasFlexible = false;
List upper = new ArrayList(types.size());
List lower = new ArrayList(types.size());
Set capabilities = new LinkedHashSet();
for (JetType type : types) {
if (TypesPackage.isFlexible(type)) {
hasFlexible = true;
Flexibility flexibility = TypesPackage.flexibility(type);
upper.add(flexibility.getUpperBound());
lower.add(flexibility.getLowerBound());
capabilities.add(flexibility.getExtraCapabilities());
}
else {
upper.add(type);
lower.add(type);
}
}
if (!hasFlexible) return commonSuperTypeForInflexible(types, recursionDepth, maxDepth);
return DelegatingFlexibleType.create(
commonSuperTypeForInflexible(lower, recursionDepth, maxDepth),
commonSuperTypeForInflexible(upper, recursionDepth, maxDepth),
KotlinPackage.single(capabilities) // mixing different capabilities is not supported
);
}
@NotNull
private static JetType commonSuperTypeForInflexible(@NotNull Collection types, int recursionDepth, int maxDepth) {
assert !types.isEmpty();
Collection typeSet = new HashSet(types);
JetType bestFit = TypesPackage.singleBestRepresentative(typeSet);
if (bestFit != null) return bestFit;
// If any of the types is nullable, the result must be nullable
// This also removed Nothing and Nothing? because they are subtypes of everything else
boolean nullable = false;
for (Iterator iterator = typeSet.iterator(); iterator.hasNext();) {
JetType type = iterator.next();
assert type != null;
assert !TypesPackage.isFlexible(type) : "Flexible type " + type + " passed to commonSuperTypeForInflexible";
if (KotlinBuiltIns.isNothingOrNullableNothing(type)) {
iterator.remove();
}
if (type.isError()) {
return ErrorUtils.createErrorType("Supertype of error type " + type);
}
nullable |= type.isMarkedNullable();
}
// Everything deleted => it's Nothing or Nothing?
if (typeSet.isEmpty()) {
// TODO : attributes
return nullable ? KotlinBuiltIns.getInstance().getNullableNothingType() : KotlinBuiltIns.getInstance().getNothingType();
}
if (typeSet.size() == 1) {
return TypeUtils.makeNullableIfNeeded(typeSet.iterator().next(), nullable);
}
// constructor of the supertype -> all of its instantiations occurring as supertypes
Map> commonSupertypes = computeCommonRawSupertypes(typeSet);
while (commonSupertypes.size() > 1) {
Set merge = new HashSet();
for (Set supertypes : commonSupertypes.values()) {
merge.addAll(supertypes);
}
commonSupertypes = computeCommonRawSupertypes(merge);
}
assert !commonSupertypes.isEmpty() : commonSupertypes + " <- " + types;
// constructor of the supertype -> all of its instantiations occurring as supertypes
Map.Entry> entry = commonSupertypes.entrySet().iterator().next();
// Reconstructing type arguments if possible
JetType result = computeSupertypeProjections(entry.getKey(), entry.getValue(), recursionDepth, maxDepth);
return TypeUtils.makeNullableIfNeeded(result, nullable);
}
// Raw supertypes are superclasses w/o type arguments
// @return TypeConstructor -> all instantiations of this constructor occurring as supertypes
@NotNull
private static Map> computeCommonRawSupertypes(@NotNull Collection types) {
assert !types.isEmpty();
Map> constructorToAllInstances = new HashMap>();
Set commonSuperclasses = null;
List order = null;
for (JetType type : types) {
Set visited = new HashSet();
order = topologicallySortSuperclassesAndRecordAllInstances(type, constructorToAllInstances, visited);
if (commonSuperclasses == null) {
commonSuperclasses = visited;
}
else {
commonSuperclasses.retainAll(visited);
}
}
assert order != null;
Set notSource = new HashSet();
Map> result = new HashMap>();
for (TypeConstructor superConstructor : order) {
if (!commonSuperclasses.contains(superConstructor)) {
continue;
}
if (!notSource.contains(superConstructor)) {
result.put(superConstructor, constructorToAllInstances.get(superConstructor));
markAll(superConstructor, notSource);
}
}
return result;
}
// constructor - type constructor of a supertype to be instantiated
// types - instantiations of constructor occurring as supertypes of classes we are trying to intersect
@NotNull
private static JetType computeSupertypeProjections(@NotNull TypeConstructor constructor, @NotNull Set types, int recursionDepth, int maxDepth) {
// we assume that all the given types are applications of the same type constructor
assert !types.isEmpty();
if (types.size() == 1) {
return types.iterator().next();
}
List parameters = constructor.getParameters();
List newProjections = new ArrayList(parameters.size());
for (TypeParameterDescriptor parameterDescriptor : parameters) {
Set typeProjections = new HashSet();
for (JetType type : types) {
typeProjections.add(type.getArguments().get(parameterDescriptor.getIndex()));
}
newProjections.add(computeSupertypeProjection(parameterDescriptor, typeProjections, recursionDepth, maxDepth));
}
boolean nullable = false;
for (JetType type : types) {
nullable |= type.isMarkedNullable();
}
ClassifierDescriptor declarationDescriptor = constructor.getDeclarationDescriptor();
JetScope newScope;
if (declarationDescriptor instanceof ClassDescriptor) {
newScope = ((ClassDescriptor) declarationDescriptor).getMemberScope(newProjections);
}
else if (declarationDescriptor instanceof TypeParameterDescriptor) {
newScope = ((TypeParameterDescriptor) declarationDescriptor).getUpperBoundsAsType().getMemberScope();
}
else {
newScope = ErrorUtils.createErrorScope("A scope for common supertype which is not a normal classifier", true);
}
return JetTypeImpl.create(Annotations.EMPTY, constructor, nullable, newProjections, newScope);
}
@NotNull
private static TypeProjection computeSupertypeProjection(
@NotNull TypeParameterDescriptor parameterDescriptor,
@NotNull Set typeProjections,
int recursionDepth, int maxDepth
) {
TypeProjection singleBestProjection = TypesPackage.singleBestRepresentative(typeProjections);
if (singleBestProjection != null) {
return singleBestProjection;
}
if (recursionDepth >= maxDepth) {
// If recursion is too deep, we cut it by taking as an ultimate supertype argument
// Example: class A : Base; class B : Base, commonSuperType(A, B) = Base
return new TypeProjectionImpl(OUT_VARIANCE, KotlinBuiltIns.getInstance().getNullableAnyType());
}
Set ins = new HashSet();
Set outs = new HashSet();
Variance variance = parameterDescriptor.getVariance();
switch (variance) {
case INVARIANT:
// Nothing
break;
case IN_VARIANCE:
outs = null;
break;
case OUT_VARIANCE:
ins = null;
break;
}
for (TypeProjection projection : typeProjections) {
Variance projectionKind = projection.getProjectionKind();
if (projectionKind.getAllowsInPosition()) {
if (ins != null) {
ins.add(projection.getType());
}
}
else {
ins = null;
}
if (projectionKind.getAllowsOutPosition()) {
if (outs != null) {
outs.add(projection.getType());
}
}
else {
outs = null;
}
}
if (outs != null) {
Variance projectionKind = variance == OUT_VARIANCE ? Variance.INVARIANT : OUT_VARIANCE;
JetType superType = findCommonSupertype(outs, recursionDepth + 1, maxDepth);
for (JetType upperBound: parameterDescriptor.getUpperBounds()) {
if (!TypeUtilPackage.isSubtypeOf(superType, upperBound)) {
return new StarProjectionImpl(parameterDescriptor);
}
}
return new TypeProjectionImpl(projectionKind, superType);
}
if (ins != null) {
JetType intersection = TypeIntersector.intersectTypes(getBuiltIns(parameterDescriptor), JetTypeChecker.DEFAULT, ins);
if (intersection == null) {
return new TypeProjectionImpl(OUT_VARIANCE, findCommonSupertype(parameterDescriptor.getUpperBounds(), recursionDepth + 1, maxDepth));
}
Variance projectionKind = variance == IN_VARIANCE ? Variance.INVARIANT : IN_VARIANCE;
return new TypeProjectionImpl(projectionKind, intersection);
}
else {
Variance projectionKind = variance == OUT_VARIANCE ? Variance.INVARIANT : OUT_VARIANCE;
return new TypeProjectionImpl(projectionKind, findCommonSupertype(parameterDescriptor.getUpperBounds(), recursionDepth + 1, maxDepth));
}
}
private static void markAll(@NotNull TypeConstructor typeConstructor, @NotNull Set markerSet) {
markerSet.add(typeConstructor);
for (JetType type : typeConstructor.getSupertypes()) {
markAll(type.getConstructor(), markerSet);
}
}
}
