JetStandardClasses and JetStandardLibrary deleted
This commit is contained in:
Andrey Breslav
@@ -1,618 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2012 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.jet.lang.types.lang;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Sets;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.jet.lang.descriptors.*;
|
||||
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
|
||||
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
|
||||
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
|
||||
import org.jetbrains.jet.lang.resolve.name.FqName;
|
||||
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
|
||||
import org.jetbrains.jet.lang.resolve.name.Name;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.*;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
|
||||
import org.jetbrains.jet.lang.types.*;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* @author abreslav
|
||||
*/
|
||||
public class JetStandardClasses {
|
||||
|
||||
private JetStandardClasses() {
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
public static final ModuleDescriptor FAKE_STANDARD_CLASSES_MODULE = new ModuleDescriptor(Name.special("<builtin>"));
|
||||
|
||||
private static final NamespaceDescriptorImpl STANDARD_CLASSES_FAKE_ROOT_NS = new NamespaceDescriptorImpl(
|
||||
FAKE_STANDARD_CLASSES_MODULE, Collections.<AnnotationDescriptor>emptyList(), FqNameUnsafe.ROOT_NAME);
|
||||
|
||||
static {
|
||||
FAKE_STANDARD_CLASSES_MODULE.setRootNamespace(STANDARD_CLASSES_FAKE_ROOT_NS);
|
||||
}
|
||||
|
||||
public static NamespaceDescriptorImpl STANDARD_CLASSES_NAMESPACE = new NamespaceDescriptorImpl(
|
||||
STANDARD_CLASSES_FAKE_ROOT_NS, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("jet"));
|
||||
|
||||
public static final FqName STANDARD_CLASSES_FQNAME = DescriptorUtils.getFQName(STANDARD_CLASSES_NAMESPACE).toSafe();
|
||||
|
||||
private static final ClassDescriptor NOTHING_CLASS;
|
||||
private static final JetType NOTHING_TYPE;
|
||||
static {
|
||||
ClassDescriptorImpl nothing = new ClassDescriptorImpl(
|
||||
STANDARD_CLASSES_NAMESPACE,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.FINAL,
|
||||
Name.identifier("Nothing")
|
||||
);
|
||||
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(nothing, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
constructorDescriptor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(), Visibilities.PRIVATE);
|
||||
NOTHING_CLASS = nothing.initialize(
|
||||
true,
|
||||
Collections.<TypeParameterDescriptor>emptyList(),
|
||||
new AbstractCollection<JetType>() {
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
return o instanceof JetType;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterator<JetType> iterator() {
|
||||
throw new UnsupportedOperationException("Don't enumerate supertypes of Nothing");
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
throw new UnsupportedOperationException("Supertypes of Nothing do not constitute a valid collection");
|
||||
}
|
||||
},
|
||||
JetScope.EMPTY,
|
||||
Collections.<ConstructorDescriptor>singleton(constructorDescriptor),
|
||||
null
|
||||
);
|
||||
NOTHING_TYPE = new JetTypeImpl(getNothing());
|
||||
constructorDescriptor.setReturnType(NOTHING_TYPE);
|
||||
}
|
||||
|
||||
private static final JetType NULLABLE_NOTHING_TYPE = new JetTypeImpl(
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
getNothing().getTypeConstructor(),
|
||||
true,
|
||||
Collections.<TypeProjection>emptyList(),
|
||||
JetScope.EMPTY);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
private static final ClassDescriptor ANY;
|
||||
private static final JetType ANY_TYPE;
|
||||
|
||||
static {
|
||||
ClassDescriptorImpl any = new ClassDescriptorImpl(
|
||||
STANDARD_CLASSES_NAMESPACE,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.OPEN,
|
||||
Name.identifier("Any")
|
||||
);
|
||||
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(any, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
constructorDescriptor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(), Visibilities.PUBLIC);
|
||||
ANY = any.initialize(
|
||||
false,
|
||||
Collections.<TypeParameterDescriptor>emptyList(),
|
||||
Collections.<JetType>emptySet(),
|
||||
JetScope.EMPTY,
|
||||
Collections.<ConstructorDescriptor>singleton(constructorDescriptor),
|
||||
null
|
||||
);
|
||||
ANY_TYPE = new JetTypeImpl(ANY.getTypeConstructor(), new JetScopeImpl() {
|
||||
@NotNull
|
||||
@Override
|
||||
public DeclarationDescriptor getContainingDeclaration() {
|
||||
return STANDARD_CLASSES_NAMESPACE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "Scope for Any";
|
||||
}
|
||||
});
|
||||
constructorDescriptor.setReturnType(ANY_TYPE);
|
||||
}
|
||||
private static final JetType NULLABLE_ANY_TYPE = new JetTypeImpl(ANY_TYPE.getAnnotations(), ANY_TYPE.getConstructor(), true, ANY_TYPE.getArguments(), ANY_TYPE.getMemberScope());
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
private static final JetType DEFAULT_BOUND = getNullableAnyType();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
public static final JetScope STUB = JetScope.EMPTY;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
public static final int MAX_TUPLE_ORDER = 22;
|
||||
|
||||
private static final Set<TypeConstructor> TUPLE_CONSTRUCTORS = Sets.newHashSet();
|
||||
|
||||
private static final ClassDescriptor[] TUPLE = new ClassDescriptor[MAX_TUPLE_ORDER + 1];
|
||||
static {
|
||||
for (int i = 0; i <= MAX_TUPLE_ORDER; i++) {
|
||||
List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
|
||||
List<ValueParameterDescriptor> constructorValueParameters = Lists.newArrayList();
|
||||
ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
|
||||
STANDARD_CLASSES_NAMESPACE,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.FINAL,
|
||||
Name.identifier("Tuple" + i));
|
||||
WritableScopeImpl writableScope = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, RedeclarationHandler.THROW_EXCEPTION, "tuples");
|
||||
for (int j = 0; j < i; j++) {
|
||||
TypeParameterDescriptor typeParameterDescriptor = TypeParameterDescriptorImpl.createWithDefaultBound(
|
||||
classDescriptor,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
false, Variance.OUT_VARIANCE, Name.identifier("T" + (j + 1)), j);
|
||||
typeParameters.add(typeParameterDescriptor);
|
||||
|
||||
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(classDescriptor, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, Visibilities.PUBLIC, false, Name.identifier("_" + (j + 1)), CallableMemberDescriptor.Kind.DECLARATION);
|
||||
propertyDescriptor.setType(typeParameterDescriptor.getDefaultType(), Collections.<TypeParameterDescriptorImpl>emptyList(), classDescriptor.getImplicitReceiver(), ReceiverDescriptor.NO_RECEIVER);
|
||||
PropertyGetterDescriptor getterDescriptor = new PropertyGetterDescriptor(propertyDescriptor, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, Visibilities.PUBLIC, false, true, CallableMemberDescriptor.Kind.DECLARATION);
|
||||
getterDescriptor.initialize(typeParameterDescriptor.getDefaultType());
|
||||
propertyDescriptor.initialize(getterDescriptor, null);
|
||||
writableScope.addPropertyDescriptor(propertyDescriptor);
|
||||
|
||||
ValueParameterDescriptorImpl valueParameterDescriptor =
|
||||
new ValueParameterDescriptorImpl(classDescriptor, j, Collections.<AnnotationDescriptor>emptyList(),
|
||||
Name.identifier("_" + (j + 1)), false, typeParameterDescriptor.getDefaultType(),
|
||||
false,
|
||||
null);
|
||||
constructorValueParameters.add(valueParameterDescriptor);
|
||||
}
|
||||
writableScope.changeLockLevel(WritableScope.LockLevel.READING);
|
||||
|
||||
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(classDescriptor, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
|
||||
TUPLE[i] = classDescriptor.initialize(
|
||||
true,
|
||||
typeParameters,
|
||||
Collections.singleton(getAnyType()),
|
||||
writableScope,
|
||||
Collections.<ConstructorDescriptor>singleton(constructorDescriptor),
|
||||
null);
|
||||
|
||||
if (i == 0) {
|
||||
// Unit.VALUE
|
||||
classDescriptor.setClassObjectDescriptor(createClassObjectForUnit(classDescriptor));
|
||||
}
|
||||
|
||||
TUPLE_CONSTRUCTORS.add(TUPLE[i].getTypeConstructor());
|
||||
|
||||
constructorDescriptor.initialize(classDescriptor.getTypeConstructor().getParameters(), constructorValueParameters, i == 0 ? Visibilities.PRIVATE : Visibilities.PUBLIC);
|
||||
constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static ClassDescriptor createClassObjectForUnit(@NotNull ClassDescriptorImpl unitClass) {
|
||||
ClassDescriptorImpl classObjectDescriptor = new ClassDescriptorImpl(
|
||||
unitClass,
|
||||
ClassKind.CLASS_OBJECT,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.FINAL,
|
||||
DescriptorUtils.getClassObjectName(unitClass.getName())
|
||||
);
|
||||
WritableScopeImpl classObjectMemberScope = new WritableScopeImpl(
|
||||
JetScope.EMPTY,
|
||||
classObjectDescriptor,
|
||||
RedeclarationHandler.DO_NOTHING,
|
||||
"Unit class object members"
|
||||
);
|
||||
PropertyDescriptor valueProperty = createUnitValueProperty(unitClass, classObjectDescriptor);
|
||||
classObjectMemberScope.addPropertyDescriptor(valueProperty);
|
||||
classObjectMemberScope.changeLockLevel(WritableScope.LockLevel.READING);
|
||||
|
||||
ConstructorDescriptorImpl classObjectConstructorDescriptor = new ConstructorDescriptorImpl(classObjectDescriptor, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
classObjectConstructorDescriptor.initialize(
|
||||
Collections.<TypeParameterDescriptor>emptyList(),
|
||||
Collections.<ValueParameterDescriptor>emptyList(),
|
||||
Visibilities.PRIVATE
|
||||
);
|
||||
|
||||
classObjectDescriptor.initialize(
|
||||
/*sealed = */ true,
|
||||
Collections.<TypeParameterDescriptor>emptyList(),
|
||||
Collections.singleton(getAnyType()),
|
||||
classObjectMemberScope,
|
||||
Collections.<ConstructorDescriptor>singleton(classObjectConstructorDescriptor),
|
||||
classObjectConstructorDescriptor
|
||||
);
|
||||
|
||||
classObjectConstructorDescriptor.setReturnType(classObjectDescriptor.getDefaultType());
|
||||
|
||||
return classObjectDescriptor;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static PropertyDescriptor createUnitValueProperty(
|
||||
@NotNull ClassDescriptorImpl unitClass,
|
||||
@NotNull ClassDescriptorImpl unitClassObject
|
||||
) {
|
||||
PropertyDescriptor valueProperty = new PropertyDescriptor(
|
||||
unitClassObject,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.FINAL,
|
||||
Visibilities.PUBLIC,
|
||||
/*isVar = */ false,
|
||||
Name.identifier("VALUE"),
|
||||
CallableMemberDescriptor.Kind.DECLARATION);
|
||||
valueProperty.setType(
|
||||
unitClass.getDefaultType(),
|
||||
Collections.<TypeParameterDescriptor>emptyList(),
|
||||
unitClassObject.getImplicitReceiver(),
|
||||
ReceiverDescriptor.NO_RECEIVER);
|
||||
PropertyGetterDescriptor getter = DescriptorResolver.createDefaultGetter(valueProperty);
|
||||
getter.initialize(unitClass.getDefaultType());
|
||||
valueProperty.initialize(getter, null);
|
||||
return valueProperty;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
public static final int MAX_FUNCTION_ORDER = 22;
|
||||
|
||||
private static final ClassDescriptor[] FUNCTION = new ClassDescriptor[MAX_FUNCTION_ORDER + 1];
|
||||
private static final ClassDescriptor[] RECEIVER_FUNCTION = new ClassDescriptor[MAX_FUNCTION_ORDER + 1];
|
||||
|
||||
private static final Set<TypeConstructor> FUNCTION_TYPE_CONSTRUCTORS = Sets.newHashSet();
|
||||
private static final Set<TypeConstructor> RECEIVER_FUNCTION_TYPE_CONSTRUCTORS = Sets.newHashSet();
|
||||
|
||||
static {
|
||||
for (int i = 0; i <= MAX_FUNCTION_ORDER; i++) {
|
||||
ClassDescriptorImpl function = new ClassDescriptorImpl(
|
||||
STANDARD_CLASSES_NAMESPACE,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.ABSTRACT,
|
||||
Name.identifier("Function" + i));
|
||||
|
||||
SimpleFunctionDescriptorImpl invoke = new SimpleFunctionDescriptorImpl(function, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("invoke"), CallableMemberDescriptor.Kind.DECLARATION);
|
||||
WritableScope scopeForInvoke = createScopeForInvokeFunction(function, invoke);
|
||||
List<TypeParameterDescriptor> typeParameters = createTypeParameters(0, i, function);
|
||||
ConstructorDescriptorImpl constructorDescriptorForFunction = new ConstructorDescriptorImpl(function, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
FUNCTION[i] = function.initialize(
|
||||
false,
|
||||
typeParameters,
|
||||
Collections.singleton(getAnyType()), scopeForInvoke, Collections.<ConstructorDescriptor>singleton(constructorDescriptorForFunction), null);
|
||||
FUNCTION_TYPE_CONSTRUCTORS.add(FUNCTION[i].getTypeConstructor());
|
||||
FunctionDescriptorUtil.initializeFromFunctionType(invoke, function.getDefaultType(), new ClassReceiver(FUNCTION[i]), Modality.ABSTRACT, Visibilities.PUBLIC);
|
||||
|
||||
constructorDescriptorForFunction.initialize(function.getTypeConstructor().getParameters(),
|
||||
Collections.<ValueParameterDescriptor>emptyList(), Visibilities.PUBLIC);
|
||||
constructorDescriptorForFunction.setReturnType(function.getDefaultType());
|
||||
|
||||
ClassDescriptorImpl receiverFunction = new ClassDescriptorImpl(
|
||||
STANDARD_CLASSES_NAMESPACE,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
Modality.ABSTRACT,
|
||||
Name.identifier("ExtensionFunction" + i));
|
||||
SimpleFunctionDescriptorImpl invokeWithReceiver = new SimpleFunctionDescriptorImpl(receiverFunction, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("invoke"), CallableMemberDescriptor.Kind.DECLARATION);
|
||||
WritableScope scopeForInvokeWithReceiver = createScopeForInvokeFunction(receiverFunction, invokeWithReceiver);
|
||||
List<TypeParameterDescriptor> parameters = createTypeParameters(1, i, receiverFunction);
|
||||
parameters.add(0, TypeParameterDescriptorImpl.createWithDefaultBound(
|
||||
receiverFunction,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
false, Variance.IN_VARIANCE, Name.identifier("T"), 0));
|
||||
|
||||
ConstructorDescriptorImpl constructorDescriptorForReceiverFunction = new ConstructorDescriptorImpl(function, Collections.<AnnotationDescriptor>emptyList(), true);
|
||||
RECEIVER_FUNCTION[i] = receiverFunction.initialize(
|
||||
false,
|
||||
parameters,
|
||||
Collections.singleton(getAnyType()), scopeForInvokeWithReceiver, Collections.<ConstructorDescriptor>singleton(
|
||||
constructorDescriptorForReceiverFunction), null);
|
||||
RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.add(RECEIVER_FUNCTION[i].getTypeConstructor());
|
||||
FunctionDescriptorUtil.initializeFromFunctionType(invokeWithReceiver, receiverFunction.getDefaultType(), new ClassReceiver(RECEIVER_FUNCTION[i]), Modality.ABSTRACT, Visibilities.PUBLIC);
|
||||
|
||||
constructorDescriptorForReceiverFunction.initialize(receiverFunction.getTypeConstructor().getParameters(),
|
||||
Collections.<ValueParameterDescriptor>emptyList(), Visibilities.PUBLIC);
|
||||
constructorDescriptorForReceiverFunction.setReturnType(receiverFunction.getDefaultType());
|
||||
}
|
||||
}
|
||||
|
||||
private static WritableScope createScopeForInvokeFunction(ClassDescriptorImpl function, SimpleFunctionDescriptorImpl invoke) {
|
||||
WritableScope scopeForInvoke = new WritableScopeImpl(STUB, function, RedeclarationHandler.THROW_EXCEPTION, "Scope for function type");
|
||||
scopeForInvoke.addFunctionDescriptor(invoke);
|
||||
scopeForInvoke.changeLockLevel(WritableScope.LockLevel.READING);
|
||||
return scopeForInvoke;
|
||||
}
|
||||
|
||||
private static List<TypeParameterDescriptor> createTypeParameters(int baseIndex, int parameterCount, ClassDescriptorImpl function) {
|
||||
List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>();
|
||||
for (int j = 0; j < parameterCount; j++) {
|
||||
parameters.add(TypeParameterDescriptorImpl.createWithDefaultBound(
|
||||
function,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
false, Variance.IN_VARIANCE, Name.identifier("P" + (j + 1)), baseIndex + j));
|
||||
}
|
||||
parameters.add(TypeParameterDescriptorImpl.createWithDefaultBound(
|
||||
function,
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
false, Variance.OUT_VARIANCE, Name.identifier("R"), baseIndex + parameterCount));
|
||||
return parameters;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
private static final JetType UNIT_TYPE = new JetTypeImpl(getTuple(0));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@NotNull
|
||||
public static final JetScope STANDARD_CLASSES;
|
||||
|
||||
public static final Name UNIT_ALIAS = Name.identifier("Unit");
|
||||
|
||||
static {
|
||||
WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.DO_NOTHING, "JetStandardClasses.STANDARD_CLASSES");
|
||||
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
|
||||
|
||||
STANDARD_CLASSES = writableScope;
|
||||
writableScope.addClassifierAlias(UNIT_ALIAS, getTuple(0));
|
||||
|
||||
Field[] declaredFields = JetStandardClasses.class.getDeclaredFields();
|
||||
for (Field field : declaredFields) {
|
||||
if ((field.getModifiers() & Modifier.STATIC) == 0) {
|
||||
continue;
|
||||
}
|
||||
Class<?> type = field.getType();
|
||||
if (type == ClassDescriptor.class) {
|
||||
try {
|
||||
ClassDescriptor descriptor = (ClassDescriptor) field.get(null);
|
||||
writableScope.addClassifierDescriptor(descriptor);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
}
|
||||
else if (type.isArray() && type.getComponentType() == ClassDescriptor.class) {
|
||||
try {
|
||||
ClassDescriptor[] array = (ClassDescriptor[]) field.get(null);
|
||||
for (ClassDescriptor descriptor : array) {
|
||||
writableScope.addClassifierDescriptor(descriptor);
|
||||
}
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
STANDARD_CLASSES_NAMESPACE.initialize(writableScope);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@NotNull
|
||||
public static JetType getDefaultBound() {
|
||||
return DEFAULT_BOUND;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ClassDescriptor getAny() {
|
||||
return ANY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static JetType getAnyType() {
|
||||
return ANY_TYPE;
|
||||
}
|
||||
|
||||
public static boolean isAny(JetType type) {
|
||||
return !(type instanceof NamespaceType) &&
|
||||
type.getConstructor() == ANY_TYPE.getConstructor();
|
||||
}
|
||||
|
||||
public static JetType getNullableAnyType() {
|
||||
return NULLABLE_ANY_TYPE;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ClassDescriptor getNothing() {
|
||||
return NOTHING_CLASS;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ClassDescriptor getTuple(int size) {
|
||||
return TUPLE[size];
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ClassDescriptor getFunction(int parameterCount) {
|
||||
return FUNCTION[parameterCount];
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static ClassDescriptor getReceiverFunction(int parameterCount) {
|
||||
return RECEIVER_FUNCTION[parameterCount];
|
||||
}
|
||||
|
||||
public static JetType getUnitType() {
|
||||
return UNIT_TYPE;
|
||||
}
|
||||
|
||||
public static JetType getNothingType() {
|
||||
return NOTHING_TYPE;
|
||||
}
|
||||
|
||||
public static JetType getNullableNothingType() {
|
||||
return NULLABLE_NOTHING_TYPE;
|
||||
}
|
||||
|
||||
public static boolean isNothing(@NotNull JetType type) {
|
||||
return isNothingOrNullableNothing(type)
|
||||
&& !type.isNullable();
|
||||
}
|
||||
|
||||
public static boolean isNothingOrNullableNothing(@NotNull JetType type) {
|
||||
return !(type instanceof NamespaceType)
|
||||
&& type.getConstructor() == NOTHING_CLASS.getTypeConstructor();
|
||||
}
|
||||
|
||||
public static boolean isUnit(@NotNull JetType type) {
|
||||
return !(type instanceof NamespaceType) &&
|
||||
type.getConstructor() == UNIT_TYPE.getConstructor();
|
||||
}
|
||||
|
||||
public static JetType getTupleType(List<AnnotationDescriptor> annotations, List<JetType> arguments) {
|
||||
if (annotations.isEmpty() && arguments.isEmpty()) {
|
||||
return getUnitType();
|
||||
}
|
||||
ClassDescriptor tuple = getTuple(arguments.size());
|
||||
List<TypeProjection> typeArguments = toProjections(arguments);
|
||||
return new JetTypeImpl(annotations, tuple.getTypeConstructor(), false, typeArguments, tuple.getMemberScope(typeArguments));
|
||||
}
|
||||
|
||||
public static JetType getTupleType(List<JetType> arguments) {
|
||||
return getTupleType(Collections.<AnnotationDescriptor>emptyList(), arguments);
|
||||
}
|
||||
|
||||
public static JetType getTupleType(JetType... arguments) {
|
||||
return getTupleType(Collections.<AnnotationDescriptor>emptyList(), Arrays.asList(arguments));
|
||||
}
|
||||
|
||||
public static boolean isTupleType(@NotNull JetType type) {
|
||||
return TUPLE_CONSTRUCTORS.contains(type.getConstructor());
|
||||
}
|
||||
|
||||
public static List<JetType> getTupleElementTypes(@NotNull JetType type) {
|
||||
assert isTupleType(type);
|
||||
List<JetType> result = Lists.newArrayList();
|
||||
for (TypeProjection typeProjection : type.getArguments()) {
|
||||
result.add(typeProjection.getType());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static JetType getLabeledTupleType(List<AnnotationDescriptor> annotations, List<ValueParameterDescriptor> arguments) {
|
||||
// TODO
|
||||
return getTupleType(annotations, toTypes(arguments));
|
||||
}
|
||||
|
||||
public static JetType getLabeledTupleType(List<ValueParameterDescriptor> arguments) {
|
||||
// TODO
|
||||
return getLabeledTupleType(Collections.<AnnotationDescriptor>emptyList(), arguments);
|
||||
}
|
||||
|
||||
private static List<TypeProjection> toProjections(List<JetType> arguments) {
|
||||
List<TypeProjection> result = new ArrayList<TypeProjection>();
|
||||
for (JetType argument : arguments) {
|
||||
result.add(new TypeProjection(Variance.OUT_VARIANCE, argument));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private static List<JetType> toTypes(List<ValueParameterDescriptor> labeledEntries) {
|
||||
List<JetType> result = new ArrayList<JetType>();
|
||||
for (ValueParameterDescriptor entry : labeledEntries) {
|
||||
result.add(entry.getType());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// TODO : labeled version?
|
||||
public static JetType getFunctionType(List<AnnotationDescriptor> annotations, @Nullable JetType receiverType, @NotNull List<JetType> parameterTypes, @NotNull JetType returnType) {
|
||||
List<TypeProjection> arguments = new ArrayList<TypeProjection>();
|
||||
if (receiverType != null) {
|
||||
arguments.add(defaultProjection(receiverType));
|
||||
}
|
||||
for (JetType parameterType : parameterTypes) {
|
||||
arguments.add(defaultProjection(parameterType));
|
||||
}
|
||||
arguments.add(defaultProjection(returnType));
|
||||
int size = parameterTypes.size();
|
||||
ClassDescriptor classDescriptor = receiverType == null ? FUNCTION[size] : RECEIVER_FUNCTION[size];
|
||||
TypeConstructor constructor = classDescriptor.getTypeConstructor();
|
||||
return new JetTypeImpl(annotations, constructor, false, arguments, classDescriptor.getMemberScope(arguments));
|
||||
}
|
||||
|
||||
private static TypeProjection defaultProjection(JetType returnType) {
|
||||
return new TypeProjection(Variance.INVARIANT, returnType);
|
||||
}
|
||||
|
||||
public static boolean isFunctionType(@NotNull JetType type) {
|
||||
return FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) || isReceiverFunctionType(type);
|
||||
}
|
||||
|
||||
public static boolean isReceiverFunctionType(@NotNull JetType type) {
|
||||
return RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor());
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public static JetType getReceiverType(@NotNull JetType type) {
|
||||
assert isFunctionType(type) : type;
|
||||
if (RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor())) {
|
||||
return type.getArguments().get(0).getType();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<ValueParameterDescriptor> getValueParameters(@NotNull FunctionDescriptor functionDescriptor, @NotNull JetType type) {
|
||||
assert isFunctionType(type);
|
||||
List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
|
||||
List<TypeProjection> parameterTypes = getParameterTypeProjectionsFromFunctionType(type);
|
||||
for (int i = 0; i < parameterTypes.size(); i++) {
|
||||
TypeProjection parameterType = parameterTypes.get(i);
|
||||
ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl(
|
||||
functionDescriptor, i, Collections.<AnnotationDescriptor>emptyList(),
|
||||
Name.identifier("p" + (i + 1)), false, parameterType.getType(), false, null);
|
||||
valueParameters.add(valueParameterDescriptor);
|
||||
}
|
||||
return valueParameters;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<TypeProjection> getParameterTypeProjectionsFromFunctionType(@NotNull JetType type) {
|
||||
assert isFunctionType(type);
|
||||
List<TypeProjection> arguments = type.getArguments();
|
||||
int first = RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) ? 1 : 0;
|
||||
int last = arguments.size() - 2;
|
||||
List<TypeProjection> parameterTypes = Lists.newArrayList();
|
||||
for (int i = first; i <= last; i++) {
|
||||
parameterTypes.add(arguments.get(i));
|
||||
}
|
||||
return parameterTypes;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static JetType getReturnTypeFromFunctionType(@NotNull JetType type) {
|
||||
assert isFunctionType(type);
|
||||
List<TypeProjection> arguments = type.getArguments();
|
||||
return arguments.get(arguments.size() - 1).getType();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static Collection<DeclarationDescriptor> getAllStandardClasses() {
|
||||
return STANDARD_CLASSES.getAllDescriptors();
|
||||
}
|
||||
|
||||
public static boolean isStandardClass(@NotNull FqName fqName) {
|
||||
return JetStandardClasses.STANDARD_CLASSES_FQNAME.equals(fqName.parent());
|
||||
}
|
||||
}
|
||||
@@ -1,612 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2012 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.jet.lang.types.lang;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.intellij.openapi.progress.ProcessCanceledException;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.openapi.util.io.FileUtil;
|
||||
import com.intellij.psi.PsiFileFactory;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
|
||||
import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
|
||||
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
|
||||
import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
|
||||
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
|
||||
import org.jetbrains.jet.lang.psi.JetFile;
|
||||
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
|
||||
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
|
||||
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
|
||||
import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
|
||||
import org.jetbrains.jet.lang.resolve.name.Name;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
|
||||
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
|
||||
import org.jetbrains.jet.lang.types.*;
|
||||
import org.jetbrains.jet.plugin.JetFileType;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* @author abreslav
|
||||
*/
|
||||
public class JetStandardLibrary {
|
||||
|
||||
private static JetStandardLibrary instance = null;
|
||||
|
||||
private static boolean initializing;
|
||||
private static Throwable initializationFailed;
|
||||
|
||||
// This method must be called at least once per application run, on any project
|
||||
// before any type checking is run
|
||||
public static synchronized void initialize(@NotNull Project project) {
|
||||
if (instance == null) {
|
||||
if (initializationFailed != null) {
|
||||
throw new RuntimeException(
|
||||
"builtin library initialization failed previously: " + initializationFailed, initializationFailed);
|
||||
}
|
||||
if (initializing) {
|
||||
throw new IllegalStateException("builtin library initialization loop");
|
||||
}
|
||||
initializing = true;
|
||||
try {
|
||||
instance = new JetStandardLibrary(project);
|
||||
}
|
||||
catch (Throwable e) {
|
||||
initializationFailed = e;
|
||||
throw new RuntimeException("builtin library initialization failed: " + e, e);
|
||||
}
|
||||
initializing = false;
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull // This asserts that initialize() is called before any resolution happens
|
||||
public static JetStandardLibrary getInstance() {
|
||||
return instance;
|
||||
}
|
||||
|
||||
private JetScope libraryScope;
|
||||
|
||||
private ClassDescriptor numberClass;
|
||||
|
||||
private ClassDescriptor charSequenceClass;
|
||||
private ClassDescriptor stringClass;
|
||||
private ClassDescriptor arrayClass;
|
||||
private ClassDescriptor iterableClass;
|
||||
private ClassDescriptor iteratorClass;
|
||||
private ClassDescriptor mutableIterableClass;
|
||||
private ClassDescriptor mutableIteratorClass;
|
||||
private ClassDescriptor comparableClass;
|
||||
private ClassDescriptor throwableClass;
|
||||
private ClassDescriptor enumClass;
|
||||
private ClassDescriptor annotationClass;
|
||||
private ClassDescriptor volatileClass;
|
||||
private ClassDescriptor dataClass;
|
||||
|
||||
private JetType stringType;
|
||||
private JetType annotationType;
|
||||
private JetType tuple0Type;
|
||||
|
||||
private EnumMap<PrimitiveType, ClassDescriptor> primitiveTypeToClass;
|
||||
private EnumMap<PrimitiveType, ClassDescriptor> primitiveTypeToArrayClass;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToJetType;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToNullableJetType;
|
||||
private EnumMap<PrimitiveType, JetType> primitiveTypeToArrayJetType;
|
||||
private Map<JetType, JetType> primitiveJetTypeToJetArrayType;
|
||||
private Map<JetType, JetType> jetArrayTypeToPrimitiveJetType;
|
||||
|
||||
private JetStandardLibrary(@NotNull Project project) {
|
||||
// TODO : review
|
||||
List<String> libraryFiles = Arrays.asList(
|
||||
"Library.jet",
|
||||
"Numbers.jet",
|
||||
"Ranges.jet",
|
||||
"Iterables.jet",
|
||||
"Iterators.jet",
|
||||
"Arrays.jet",
|
||||
"Enum.jet",
|
||||
"Collections.jet"
|
||||
);
|
||||
try {
|
||||
List<JetFile> files = new LinkedList<JetFile>();
|
||||
for(String fileName : libraryFiles) {
|
||||
String path = "jet/" + fileName;
|
||||
InputStream stream = JetStandardClasses.class.getClassLoader().getResourceAsStream(path);
|
||||
|
||||
if (stream == null) {
|
||||
throw new IllegalStateException("resource not found in classpath: " + path);
|
||||
}
|
||||
|
||||
//noinspection IOResourceOpenedButNotSafelyClosed
|
||||
JetFile file = (JetFile) PsiFileFactory.getInstance(project).createFileFromText(fileName,
|
||||
JetFileType.INSTANCE, FileUtil.loadTextAndClose(new InputStreamReader(stream)));
|
||||
files.add(file);
|
||||
}
|
||||
|
||||
BindingTraceContext bindingTraceContext = new BindingTraceContext();
|
||||
WritableScopeImpl writableScope = new WritableScopeImpl(
|
||||
JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE,
|
||||
RedeclarationHandler.THROW_EXCEPTION, "Root bootstrap scope");
|
||||
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
|
||||
TopDownAnalyzer.processStandardLibraryNamespace(project, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, files);
|
||||
|
||||
AnalyzingUtils.throwExceptionOnErrors(bindingTraceContext.getBindingContext());
|
||||
initStdClasses();
|
||||
} catch (IOException e) {
|
||||
throw new IllegalStateException(e);
|
||||
} catch (ProcessCanceledException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
public JetScope getLibraryScope() {
|
||||
initStdClasses();
|
||||
return libraryScope;
|
||||
}
|
||||
|
||||
private void initStdClasses() {
|
||||
if (libraryScope == null) {
|
||||
this.libraryScope = JetStandardClasses.STANDARD_CLASSES_NAMESPACE.getMemberScope();
|
||||
|
||||
this.numberClass = getStdClassByName("Number");
|
||||
this.stringClass = getStdClassByName("String");
|
||||
this.charSequenceClass = getStdClassByName("CharSequence");
|
||||
this.arrayClass = getStdClassByName("Array");
|
||||
this.throwableClass = getStdClassByName("Throwable");
|
||||
this.enumClass = getStdClassByName("Enum");
|
||||
|
||||
this.volatileClass = getStdClassByName("volatile");
|
||||
this.dataClass = getStdClassByName("data");
|
||||
|
||||
this.iterableClass = getStdClassByName("Iterable");
|
||||
this.iteratorClass = getStdClassByName("Iterator");
|
||||
this.mutableIterableClass = getStdClassByName("MutableIterable");
|
||||
this.mutableIteratorClass = getStdClassByName("MutableIterator");
|
||||
this.comparableClass = getStdClassByName("Comparable");
|
||||
|
||||
this.stringType = new JetTypeImpl(getString());
|
||||
this.tuple0Type = new JetTypeImpl(JetStandardClasses.getTuple(0));
|
||||
|
||||
this.annotationClass = getStdClassByName("Annotation");
|
||||
this.annotationType = new JetTypeImpl(annotationClass);
|
||||
|
||||
primitiveTypeToClass = new EnumMap<PrimitiveType, ClassDescriptor>(PrimitiveType.class);
|
||||
primitiveTypeToJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveTypeToNullableJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveTypeToArrayClass = new EnumMap<PrimitiveType, ClassDescriptor>(PrimitiveType.class);
|
||||
primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
|
||||
primitiveJetTypeToJetArrayType = new HashMap<JetType, JetType>();
|
||||
jetArrayTypeToPrimitiveJetType = new HashMap<JetType, JetType>();
|
||||
|
||||
for (PrimitiveType primitive : PrimitiveType.values()) {
|
||||
makePrimitive(primitive);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private ClassDescriptor getStdClassByName(String className) {
|
||||
ClassDescriptor classDescriptor = (ClassDescriptor) libraryScope.getClassifier(Name.identifier(className));
|
||||
assert classDescriptor != null : "Standard class not found: " + className;
|
||||
return classDescriptor;
|
||||
}
|
||||
|
||||
private void makePrimitive(PrimitiveType primitiveType) {
|
||||
ClassDescriptor clazz = (ClassDescriptor) libraryScope.getClassifier(primitiveType.getTypeName());
|
||||
ClassDescriptor arrayClazz = (ClassDescriptor) libraryScope.getClassifier(primitiveType.getArrayTypeName());
|
||||
JetTypeImpl type = new JetTypeImpl(clazz);
|
||||
JetTypeImpl arrayType = new JetTypeImpl(arrayClazz);
|
||||
|
||||
primitiveTypeToClass.put(primitiveType, clazz);
|
||||
primitiveTypeToJetType.put(primitiveType, type);
|
||||
primitiveTypeToNullableJetType.put(primitiveType, TypeUtils.makeNullable(type));
|
||||
primitiveTypeToArrayClass.put(primitiveType, arrayClazz);
|
||||
primitiveTypeToArrayJetType.put(primitiveType, arrayType);
|
||||
primitiveJetTypeToJetArrayType.put(type, arrayType);
|
||||
jetArrayTypeToPrimitiveJetType.put(arrayType, type);
|
||||
}
|
||||
|
||||
public Set<DeclarationDescriptor> getIntegralRanges() {
|
||||
initStdClasses();
|
||||
|
||||
return ImmutableSet.<DeclarationDescriptor>of(
|
||||
getStdClassByName("ByteRange"),
|
||||
getStdClassByName("ShortRange"),
|
||||
getStdClassByName("CharRange"),
|
||||
getStdClassByName("IntRange"),
|
||||
getStdClassByName("LongRange")
|
||||
);
|
||||
}
|
||||
|
||||
public Collection<ClassDescriptor> getStandardTypes() {
|
||||
initStdClasses();
|
||||
|
||||
Collection<ClassDescriptor> classDescriptors = new ArrayList<ClassDescriptor>(primitiveTypeToClass.values());
|
||||
classDescriptors.add(numberClass);
|
||||
classDescriptors.add(stringClass);
|
||||
classDescriptors.add(charSequenceClass);
|
||||
classDescriptors.add(arrayClass);
|
||||
classDescriptors.add(throwableClass);
|
||||
classDescriptors.add(iterableClass);
|
||||
classDescriptors.add(iteratorClass);
|
||||
classDescriptors.add(mutableIterableClass);
|
||||
classDescriptors.add(mutableIteratorClass);
|
||||
classDescriptors.add(comparableClass);
|
||||
classDescriptors.add(enumClass);
|
||||
|
||||
return classDescriptors;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getNumber() {
|
||||
initStdClasses();
|
||||
return numberClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getPrimitiveClassDescriptor(PrimitiveType primitiveType) {
|
||||
initStdClasses();
|
||||
return primitiveTypeToClass.get(primitiveType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getPrimitiveArrayClassDescriptor(PrimitiveType primitiveType) {
|
||||
initStdClasses();
|
||||
return primitiveTypeToArrayClass.get(primitiveType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getByte() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.BYTE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getChar() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.CHAR);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getShort() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.SHORT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getInt() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.INT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getLong() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.LONG);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getFloat() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.FLOAT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getDouble() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.DOUBLE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getBoolean() {
|
||||
return getPrimitiveClassDescriptor(PrimitiveType.BOOLEAN);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getString() {
|
||||
initStdClasses();
|
||||
return stringClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getCharSequence() {
|
||||
initStdClasses();
|
||||
return charSequenceClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getArray() {
|
||||
initStdClasses();
|
||||
return arrayClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getIterable() {
|
||||
initStdClasses();
|
||||
return iterableClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getIterator() {
|
||||
initStdClasses();
|
||||
return iteratorClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableIterable() {
|
||||
initStdClasses();
|
||||
return mutableIterableClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableIterator() {
|
||||
initStdClasses();
|
||||
return mutableIteratorClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getComparable() {
|
||||
initStdClasses();
|
||||
return comparableClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getThrowable() {
|
||||
initStdClasses();
|
||||
return throwableClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getEnum() {
|
||||
initStdClasses();
|
||||
return enumClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getAnnotation() {
|
||||
initStdClasses();
|
||||
return annotationClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getAnnotationType() {
|
||||
initStdClasses();
|
||||
return annotationType;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getCollection() {
|
||||
return getStdClassByName("Collection");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableCollection() {
|
||||
return getStdClassByName("MutableCollection");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getList() {
|
||||
return getStdClassByName("List");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableList() {
|
||||
return getStdClassByName("MutableList");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getListIterator() {
|
||||
return getStdClassByName("ListIterator");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableListIterator() {
|
||||
return getStdClassByName("MutableListIterator");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getSet() {
|
||||
return getStdClassByName("Set");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableSet() {
|
||||
return getStdClassByName("MutableSet");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMap() {
|
||||
return getStdClassByName("Map");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableMap() {
|
||||
return getStdClassByName("MutableMap");
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMapEntry() {
|
||||
ClassifierDescriptor entry = DescriptorUtils.getInnerClassByName(getMap(), "Entry");
|
||||
assert entry instanceof ClassDescriptor;
|
||||
return (ClassDescriptor) entry;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getMutableMapEntry() {
|
||||
ClassifierDescriptor entry = DescriptorUtils.getInnerClassByName(getMutableMap(), "MutableEntry");
|
||||
assert entry instanceof ClassDescriptor;
|
||||
return (ClassDescriptor) entry;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getPrimitiveJetType(PrimitiveType primitiveType) {
|
||||
return primitiveTypeToJetType.get(primitiveType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getIntType() {
|
||||
return getPrimitiveJetType(PrimitiveType.INT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getLongType() {
|
||||
return getPrimitiveJetType(PrimitiveType.LONG);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getDoubleType() {
|
||||
return getPrimitiveJetType(PrimitiveType.DOUBLE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getFloatType() {
|
||||
return getPrimitiveJetType(PrimitiveType.FLOAT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getCharType() {
|
||||
return getPrimitiveJetType(PrimitiveType.CHAR);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getBooleanType() {
|
||||
return getPrimitiveJetType(PrimitiveType.BOOLEAN);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getStringType() {
|
||||
initStdClasses();
|
||||
return stringType;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getByteType() {
|
||||
return getPrimitiveJetType(PrimitiveType.BYTE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getShortType() {
|
||||
return getPrimitiveJetType(PrimitiveType.SHORT);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getArrayType(@NotNull JetType argument) {
|
||||
return getArrayType(Variance.INVARIANT, argument);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getEnumType(@NotNull JetType argument) {
|
||||
return getEnumType(Variance.INVARIANT, argument);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ClassDescriptor getDataClassAnnotation() {
|
||||
return dataClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getArrayType(@NotNull Variance projectionType, @NotNull JetType argument) {
|
||||
List<TypeProjection> types = Collections.singletonList(new TypeProjection(projectionType, argument));
|
||||
return new JetTypeImpl(
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
getArray().getTypeConstructor(),
|
||||
false,
|
||||
types,
|
||||
getArray().getMemberScope(types)
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getEnumType(@NotNull Variance projectionType, @NotNull JetType argument) {
|
||||
List<TypeProjection> types = Collections.singletonList(new TypeProjection(projectionType, argument));
|
||||
return new JetTypeImpl(
|
||||
Collections.<AnnotationDescriptor>emptyList(),
|
||||
getEnum().getTypeConstructor(),
|
||||
false,
|
||||
types,
|
||||
getEnum().getMemberScope(types)
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getArrayElementType(@NotNull JetType arrayType) {
|
||||
// make non-null?
|
||||
if (arrayType.getConstructor().getDeclarationDescriptor() == getArray()) {
|
||||
if (arrayType.getArguments().size() != 1) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
return arrayType.getArguments().get(0).getType();
|
||||
}
|
||||
JetType primitiveType = jetArrayTypeToPrimitiveJetType.get(arrayType);
|
||||
if (primitiveType == null) {
|
||||
throw new IllegalStateException("not array: " + arrayType);
|
||||
}
|
||||
return primitiveType;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getNullablePrimitiveJetType(PrimitiveType primitiveType) {
|
||||
initStdClasses();
|
||||
return primitiveTypeToNullableJetType.get(primitiveType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public JetType getPrimitiveArrayJetType(PrimitiveType primitiveType) {
|
||||
initStdClasses();
|
||||
return primitiveTypeToArrayJetType.get(primitiveType);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return <code>null</code> if not primitive
|
||||
*/
|
||||
@Nullable
|
||||
public JetType getPrimitiveArrayJetTypeByPrimitiveJetType(JetType jetType) {
|
||||
return primitiveJetTypeToJetArrayType.get(jetType);
|
||||
}
|
||||
|
||||
public boolean isVolatile(@NotNull PropertyDescriptor descriptor) {
|
||||
return containsAnnotation(descriptor, volatileClass);
|
||||
}
|
||||
|
||||
public static boolean isData(@NotNull ClassDescriptor descriptor) {
|
||||
if (initializing) {
|
||||
// This is a hack to make this method callable while resolving standard library
|
||||
// (otherwise getInstance() would throw an Exception)
|
||||
// This also means that "data" annotation has no effect in standard library
|
||||
return false;
|
||||
}
|
||||
return containsAnnotation(descriptor, getInstance().dataClass);
|
||||
}
|
||||
|
||||
private static boolean containsAnnotation(DeclarationDescriptor descriptor, ClassDescriptor annotationClass) {
|
||||
List<AnnotationDescriptor> annotations = descriptor.getOriginal().getAnnotations();
|
||||
if (annotations != null) {
|
||||
for (AnnotationDescriptor annotation : annotations) {
|
||||
if (annotationClass.equals(annotation.getType().getConstructor().getDeclarationDescriptor())) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isArray(@NotNull JetType type) {
|
||||
return getArray().equals(type.getConstructor().getDeclarationDescriptor());
|
||||
}
|
||||
|
||||
public JetType getTuple0Type() {
|
||||
return tuple0Type;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user