azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into incremental

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2014-06-19 11:43:11 +04:00
parent f6129732a2 209315baad
commit aa41ae09ed
89 changed files with 1305 additions and 808 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java
+10 -15
View File
@@ -19,8 +19,8 @@ package org.jetbrains.jet.descriptors.serialization;
import kotlin.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
import org.jetbrains.jet.descriptors.serialization.descriptors.*;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
@@ -28,26 +28,21 @@ import org.jetbrains.jet.storage.StorageManager;
public abstract class AbstractDescriptorFinder implements DescriptorFinder {
private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> findClass;
private final Deserializers deserializers;
public AbstractDescriptorFinder(
@NotNull final StorageManager storageManager,
@NotNull Deserializers deserializers,
@NotNull final PackageFragmentProvider packageFragmentProvider
@NotNull StorageManager storageManager,
@NotNull AnnotationLoader annotationLoader,
@NotNull ConstantLoader constantLoader,
@NotNull PackageFragmentProvider packageFragmentProvider
) {
this.deserializers = deserializers;
final DeserializationGlobalContext deserializationGlobalContext =
new DeserializationGlobalContext(storageManager, this, annotationLoader, constantLoader,
packageFragmentProvider);
this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
@Override
public ClassDescriptor invoke(ClassId classId) {
ClassData classData = getClassData(classId);
if (classData == null) {
return null;
}
AbstractDescriptorFinder _this = AbstractDescriptorFinder.this;
return new DeserializedClassDescriptor(storageManager, _this.deserializers, _this, packageFragmentProvider,
classData.getNameResolver(), classData.getClassProto());
return classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData);
}
});
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java → core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.java
+54 -201
View File
@@ -19,15 +19,17 @@ package org.jetbrains.jet.descriptors.serialization;
import kotlin.Function0;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
import org.jetbrains.jet.descriptors.serialization.descriptors.*;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
import org.jetbrains.jet.lang.descriptors.impl.*;
import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PropertyGetterDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PropertySetterDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.DescriptorFactory;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.types.Variance;
import org.jetbrains.jet.storage.StorageManager;
import java.util.ArrayList;
import java.util.Collections;
@@ -35,86 +37,14 @@ import java.util.List;
import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable;
import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter;
import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE;
import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*;
public class DescriptorDeserializer {
public class MemberDeserializer {
@NotNull
public static DescriptorDeserializer create(
@NotNull StorageManager storageManager,
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull NameResolver nameResolver,
@NotNull DescriptorFinder descriptorFinder,
@NotNull Deserializers deserializers
) {
return new DescriptorDeserializer(storageManager,
new TypeDeserializer(storageManager, null, nameResolver, descriptorFinder,
"Deserializer for " + containingDeclaration.getName(), NONE),
containingDeclaration, nameResolver, deserializers);
}
private final DeserializationContextWithTypes context;
@NotNull
public static DescriptorDeserializer create(
@NotNull StorageManager storageManager,
@NotNull TypeDeserializer typeDeserializer,
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull NameResolver nameResolver,
@NotNull Deserializers deserializers
) {
return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, deserializers);
}
private final DeclarationDescriptor containingDeclaration;
private final NameResolver nameResolver;
private final TypeDeserializer typeDeserializer;
private final Deserializers deserializers;
private final StorageManager storageManager;
private DescriptorDeserializer(
@NotNull StorageManager storageManager,
@NotNull TypeDeserializer typeDeserializer,
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull NameResolver nameResolver,
@NotNull Deserializers deserializers
) {
this.storageManager = storageManager;
this.typeDeserializer = typeDeserializer;
this.containingDeclaration = containingDeclaration;
this.nameResolver = nameResolver;
this.deserializers = deserializers;
}
@NotNull
public TypeDeserializer getTypeDeserializer() {
return typeDeserializer;
}
@NotNull
public NameResolver getNameResolver() {
return nameResolver;
}
@NotNull
public DescriptorDeserializer createChildDeserializer(
@NotNull DeclarationDescriptor descriptor,
@NotNull final List<TypeParameter> typeParameterProtos,
@NotNull final List<TypeParameterDescriptor> typeParameters
) {
TypeDeserializer childTypeDeserializer = new TypeDeserializer(
storageManager,
typeDeserializer, "Child deserializer for " + descriptor.getName(),
new TypeDeserializer.TypeParameterResolver() {
@NotNull
@Override
public List<DeserializedTypeParameterDescriptor> getTypeParameters(@NotNull TypeDeserializer typeDeserializer) {
List<DeserializedTypeParameterDescriptor> descriptors = typeParameters(typeParameterProtos, typeDeserializer);
typeParameters.addAll(descriptors);
return descriptors;
}
});
return create(storageManager, childTypeDeserializer, descriptor, nameResolver, deserializers);
public MemberDeserializer(@NotNull DeserializationContextWithTypes context) {
this.context = context;
}
@NotNull
@@ -137,25 +67,25 @@ public class DescriptorDeserializer {
final int flags = proto.getFlags();
DeserializedPropertyDescriptor property = new DeserializedPropertyDescriptor(
containingDeclaration,
context.getContainingDeclaration(),
null,
getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
modality(Flags.MODALITY.get(flags)),
visibility(Flags.VISIBILITY.get(flags)),
Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR,
nameResolver.getName(proto.getName()),
memberKind(Flags.MEMBER_KIND.get(flags)),
context.getNameResolver().getName(proto.getName()),
SerializationPackage.memberKind(Flags.MEMBER_KIND.get(flags)),
proto,
nameResolver
context.getNameResolver()
);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
DescriptorDeserializer local = createChildDeserializer(property, proto.getTypeParameterList(), typeParameters);
DeserializationContextWithTypes local = context.childContext(property, proto.getTypeParameterList(), typeParameters);
property.setType(
local.typeDeserializer.type(proto.getReturnType()),
local.getTypeDeserializer().type(proto.getReturnType()),
typeParameters,
getExpectedThisObject(),
local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null)
local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null)
);
PropertyGetterDescriptorImpl getter = null;
@@ -168,7 +98,8 @@ public class DescriptorDeserializer {
getter = new PropertyGetterDescriptorImpl(property,
getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER),
modality(Flags.MODALITY.get(getterFlags)),
visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault,
visibility(Flags.VISIBILITY.get(getterFlags)),
isNotDefault, !isNotDefault,
property.getKind(), null);
}
else {
@@ -184,11 +115,13 @@ public class DescriptorDeserializer {
setter = new PropertySetterDescriptorImpl(property,
getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER),
modality(Flags.MODALITY.get(setterFlags)),
visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault,
visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault,
!isNotDefault,
property.getKind(), null);
DescriptorDeserializer setterLocal = local.createChildDeserializer(setter, Collections.<TypeParameter>emptyList(),
Collections.<TypeParameterDescriptor>emptyList());
List<ValueParameterDescriptor> valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
DeserializationContextWithTypes setterLocal = local.childContext(setter, Collections.<TypeParameter>emptyList(),
Collections.<TypeParameterDescriptor>emptyList());
List<ValueParameterDescriptor> valueParameters
= setterLocal.getDeserializer().valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
assert valueParameters.size() == 1 : "Property setter should have a single value parameter: " + setter;
setter.initialize(valueParameters.get(0));
}
@@ -199,16 +132,16 @@ public class DescriptorDeserializer {
if (Flags.HAS_CONSTANT.get(flags)) {
property.setCompileTimeInitializer(
storageManager.createNullableLazyValue(new Function0<CompileTimeConstant<?>>() {
context.getStorageManager().createNullableLazyValue(new Function0<CompileTimeConstant<?>>() {
@Nullable
@Override
public CompileTimeConstant<?> invoke() {
DeclarationDescriptor containingDeclaration = context.getContainingDeclaration();
assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor
: "Only members in classes or package fragments should be serialized: " + containingDeclaration;
return deserializers.getConstantDeserializer().loadPropertyConstant(
(ClassOrPackageFragmentDescriptor) containingDeclaration,
proto, nameResolver,
AnnotatedCallableKind.PROPERTY);
return context.getConstantLoader().loadPropertyConstant(
(ClassOrPackageFragmentDescriptor) containingDeclaration, proto,
context.getNameResolver(), AnnotatedCallableKind.PROPERTY);
}
})
);
@@ -223,18 +156,16 @@ public class DescriptorDeserializer {
private CallableMemberDescriptor loadFunction(@NotNull Callable proto) {
int flags = proto.getFlags();
DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create(
containingDeclaration, proto,
deserializers,
nameResolver
context.getContainingDeclaration(), proto, context.getAnnotationLoader(), context.getNameResolver()
);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
DescriptorDeserializer local = createChildDeserializer(function, proto.getTypeParameterList(), typeParameters);
DeserializationContextWithTypes local = context.childContext(function, proto.getTypeParameterList(), typeParameters);
function.initialize(
local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null),
local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null),
getExpectedThisObject(),
typeParameters,
local.valueParameters(proto, AnnotatedCallableKind.FUNCTION),
local.typeDeserializer.type(proto.getReturnType()),
local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION),
local.getTypeDeserializer().type(proto.getReturnType()),
modality(Flags.MODALITY.get(flags)),
visibility(Flags.VISIBILITY.get(flags))
);
@@ -243,33 +174,34 @@ public class DescriptorDeserializer {
@Nullable
private ReceiverParameterDescriptor getExpectedThisObject() {
DeclarationDescriptor containingDeclaration = context.getContainingDeclaration();
return containingDeclaration instanceof ClassDescriptor
? ((ClassDescriptor) containingDeclaration).getThisAsReceiverParameter() : null;
}
@NotNull
private CallableMemberDescriptor loadConstructor(@NotNull Callable proto) {
ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
ClassDescriptor classDescriptor = (ClassDescriptor) context.getContainingDeclaration();
ConstructorDescriptorImpl descriptor = ConstructorDescriptorImpl.create(
classDescriptor,
getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION),
// TODO: primary
true);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
DescriptorDeserializer local = createChildDeserializer(descriptor, Collections.<TypeParameter>emptyList(), typeParameters);
DeserializationContextWithTypes local = context.childContext(descriptor, Collections.<TypeParameter>emptyList(), typeParameters);
descriptor.initialize(
classDescriptor.getTypeConstructor().getParameters(),
local.valueParameters(proto, AnnotatedCallableKind.FUNCTION),
local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION),
visibility(Flags.VISIBILITY.get(proto.getFlags())),
DescriptorUtils.isConstructorOfStaticNestedClass(descriptor)
);
descriptor.setReturnType(local.typeDeserializer.type(proto.getReturnType()));
descriptor.setReturnType(local.getTypeDeserializer().type(proto.getReturnType()));
return descriptor;
}
@NotNull
private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) {
return getAnnotations(containingDeclaration, proto, flags, kind, deserializers.getAnnotationDeserializer(), nameResolver);
return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationLoader(), context.getNameResolver());
}
public static Annotations getAnnotations(
@@ -277,80 +209,13 @@ public class DescriptorDeserializer {
@NotNull Callable proto,
int flags,
@NotNull AnnotatedCallableKind kind,
@NotNull AnnotationDeserializer annotationDeserializer,
@NotNull AnnotationLoader annotationLoader,
@NotNull NameResolver nameResolver
) {
assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor
: "Only members in classes or package fragments should be serialized: " + containingDeclaration;
return Flags.HAS_ANNOTATIONS.get(flags)
? annotationDeserializer
.loadCallableAnnotations((ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind)
: Annotations.EMPTY;
}
public static CallableMemberDescriptor.Kind memberKind(Callable.MemberKind memberKind) {
switch (memberKind) {
case DECLARATION:
return CallableMemberDescriptor.Kind.DECLARATION;
case FAKE_OVERRIDE:
return CallableMemberDescriptor.Kind.FAKE_OVERRIDE;
case DELEGATION:
return CallableMemberDescriptor.Kind.DELEGATION;
case SYNTHESIZED:
return CallableMemberDescriptor.Kind.SYNTHESIZED;
}
throw new IllegalArgumentException("Unknown member kind: " + memberKind);
}
@NotNull
public static Modality modality(@NotNull ProtoBuf.Modality modality) {
switch (modality) {
case FINAL:
return Modality.FINAL;
case OPEN:
return Modality.OPEN;
case ABSTRACT:
return Modality.ABSTRACT;
}
throw new IllegalArgumentException("Unknown modality: " + modality);
}
@NotNull
public static Visibility visibility(@NotNull ProtoBuf.Visibility visibility) {
switch (visibility) {
case INTERNAL:
return Visibilities.INTERNAL;
case PRIVATE:
return Visibilities.PRIVATE;
case PROTECTED:
return Visibilities.PROTECTED;
case PUBLIC:
return Visibilities.PUBLIC;
case EXTRA:
throw new UnsupportedOperationException("Extra visibilities are not supported yet"); // TODO
}
throw new IllegalArgumentException("Unknown visibility: " + visibility);
}
@NotNull
public static ClassKind classKind(@NotNull ProtoBuf.Class.Kind kind) {
switch (kind) {
case CLASS:
return ClassKind.CLASS;
case TRAIT:
return ClassKind.TRAIT;
case ENUM_CLASS:
return ClassKind.ENUM_CLASS;
case ENUM_ENTRY:
return ClassKind.ENUM_ENTRY;
case ANNOTATION_CLASS:
return ClassKind.ANNOTATION_CLASS;
case OBJECT:
return ClassKind.OBJECT;
case CLASS_OBJECT:
return ClassKind.CLASS_OBJECT;
}
throw new IllegalArgumentException("Unknown class kind: " + kind);
return Flags.HAS_ANNOTATIONS.get(flags) ? annotationLoader.loadCallableAnnotations(
(ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) : Annotations.EMPTY;
}
@NotNull
@@ -362,11 +227,11 @@ public class DescriptorDeserializer {
for (int i = 0; i < protos.size(); i++) {
TypeParameter proto = protos.get(i);
DeserializedTypeParameterDescriptor descriptor = new DeserializedTypeParameterDescriptor(
storageManager,
context.getStorageManager(),
typeDeserializer,
proto,
containingDeclaration,
nameResolver.getName(proto.getName()),
context.getContainingDeclaration(),
context.getNameResolver().getName(proto.getName()),
variance(proto.getVariance()),
proto.getReified(),
i
@@ -376,21 +241,9 @@ public class DescriptorDeserializer {
return result;
}
private static Variance variance(TypeParameter.Variance proto) {
switch (proto) {
case IN:
return Variance.IN_VARIANCE;
case OUT:
return Variance.OUT_VARIANCE;
case INV:
return Variance.INVARIANT;
}
throw new IllegalStateException("Unknown projection: " + proto);
}
@NotNull
private List<ValueParameterDescriptor> valueParameters(@NotNull Callable callable, @NotNull AnnotatedCallableKind kind) {
DeclarationDescriptor containerOfCallable = containingDeclaration.getContainingDeclaration();
DeclarationDescriptor containerOfCallable = context.getContainingDeclaration().getContainingDeclaration();
assert containerOfCallable instanceof ClassOrPackageFragmentDescriptor
: "Only members in classes or package fragments should be serialized: " + containerOfCallable;
ClassOrPackageFragmentDescriptor classOrPackage = (ClassOrPackageFragmentDescriptor) containerOfCallable;
@@ -400,14 +253,14 @@ public class DescriptorDeserializer {
for (int i = 0; i < protos.size(); i++) {
Callable.ValueParameter proto = protos.get(i);
result.add(new ValueParameterDescriptorImpl(
containingDeclaration,
context.getContainingDeclaration(),
null,
i,
getAnnotations(classOrPackage, callable, kind, proto),
nameResolver.getName(proto.getName()),
typeDeserializer.type(proto.getType()),
context.getNameResolver().getName(proto.getName()),
context.getTypeDeserializer().type(proto.getType()),
Flags.DECLARES_DEFAULT_VALUE.get(proto.getFlags()),
typeDeserializer.typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null))
context.getTypeDeserializer().typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null))
);
}
return result;
@@ -420,8 +273,8 @@ public class DescriptorDeserializer {
@NotNull AnnotatedCallableKind kind,
@NotNull Callable.ValueParameter valueParameter
) {
return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())
? deserializers.getAnnotationDeserializer().loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter)
return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) ? context.getAnnotationLoader()
.loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
: Annotations.EMPTY;
}
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java
+21 -50
View File
@@ -21,6 +21,8 @@ import kotlin.Function0;
import kotlin.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.ReadOnly;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
@@ -30,12 +32,13 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
import org.jetbrains.jet.storage.NotNullLazyValue;
import org.jetbrains.jet.storage.StorageManager;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.variance;
public class TypeDeserializer {
public interface TypeParameterResolver {
@@ -48,11 +51,10 @@ public class TypeDeserializer {
};
@NotNull
@ReadOnly
List<DeserializedTypeParameterDescriptor> getTypeParameters(@NotNull TypeDeserializer typeDeserializer);
}
private final NameResolver nameResolver;
private final DescriptorFinder descriptorFinder;
private final TypeDeserializer parent;
// never written to after constructor returns
@@ -62,45 +64,29 @@ public class TypeDeserializer {
private final String debugName;
private final StorageManager storageManager;
private final DeserializationContext context;
public TypeDeserializer(
@NotNull StorageManager storageManager,
@NotNull TypeDeserializer parent,
@NotNull String debugName,
@NotNull TypeParameterResolver typeParameterResolver
) {
this(storageManager, parent, parent.nameResolver, parent.descriptorFinder, debugName, typeParameterResolver);
}
public TypeDeserializer(
@NotNull StorageManager storageManager,
@NotNull DeserializationContext context,
@Nullable TypeDeserializer parent,
@NotNull NameResolver nameResolver,
@NotNull DescriptorFinder descriptorFinder,
@NotNull String debugName,
@NotNull TypeParameterResolver typeParameterResolver
) {
this.storageManager = storageManager;
this.parent = parent;
this.nameResolver = nameResolver;
this.descriptorFinder = descriptorFinder;
this.debugName = debugName + (parent == null ? "" : ". Child of " + parent.debugName);
this.context = context;
for (DeserializedTypeParameterDescriptor typeParameterDescriptor : typeParameterResolver.getTypeParameters(this)) {
typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor);
}
this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1<Integer, ClassDescriptor>() {
@Override
public ClassDescriptor invoke(Integer fqNameIndex) {
return computeClassDescriptor(fqNameIndex);
}
});
}
/* package */ DescriptorFinder getDescriptorFinder() {
return descriptorFinder;
this.classDescriptors = context.getStorageManager().createMemoizedFunctionWithNullableValues(
new Function1<Integer, ClassDescriptor>() {
@Override
public ClassDescriptor invoke(Integer fqNameIndex) {
return computeClassDescriptor(fqNameIndex);
}
});
}
@Nullable
@@ -122,7 +108,7 @@ public class TypeDeserializer {
TypeConstructor typeConstructor = typeConstructor(constructorProto);
if (typeConstructor == null) {
String message = constructorProto.getKind() == ProtoBuf.Type.Constructor.Kind.CLASS
? nameResolver.getClassId(id).asSingleFqName().asString()
? context.getNameResolver().getClassId(id).asSingleFqName().asString()
: "Unknown type parameter " + id;
typeConstructor = ErrorUtils.createErrorType(message).getConstructor();
}
@@ -159,8 +145,8 @@ public class TypeDeserializer {
@Nullable
private ClassDescriptor computeClassDescriptor(int fqNameIndex) {
ClassId classId = nameResolver.getClassId(fqNameIndex);
return descriptorFinder.findClass(classId);
ClassId classId = context.getNameResolver().getClassId(fqNameIndex);
return context.getDescriptorFinder().findClass(classId);
}
private List<TypeProjection> typeArguments(List<ProtoBuf.Type.Argument> protos) {
@@ -172,22 +158,7 @@ public class TypeDeserializer {
}
private TypeProjection typeProjection(ProtoBuf.Type.Argument proto) {
return new TypeProjectionImpl(
variance(proto.getProjection()),
type(proto.getType())
);
}
private static Variance variance(ProtoBuf.Type.Argument.Projection proto) {
switch (proto) {
case IN:
return Variance.IN_VARIANCE;
case OUT:
return Variance.OUT_VARIANCE;
case INV:
return Variance.INVARIANT;
}
throw new IllegalStateException("Unknown projection: " + proto);
return new TypeProjectionImpl(variance(proto.getProjection()), type(proto.getType()));
}
@NotNull
@@ -215,13 +186,13 @@ public class TypeDeserializer {
this.typeProto = proto;
this.arguments = typeArguments(proto.getArgumentList());
this.constructor = storageManager.createLazyValue(new Function0<TypeConstructor>() {
this.constructor = context.getStorageManager().createLazyValue(new Function0<TypeConstructor>() {
@Override
public TypeConstructor invoke() {
return typeConstructor(typeProto);
}
});
this.memberScope = storageManager.createLazyValue(new Function0<JetScope>() {
this.memberScope = context.getStorageManager().createLazyValue(new Function0<JetScope>() {
@Override
public JetScope invoke() {
return computeMemberScope();
core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt
+101
View File
@@ -0,0 +1,101 @@
/*
* Copyright 2010-2014 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.descriptors.serialization.context
import org.jetbrains.jet.storage.StorageManager
import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader
import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
import org.jetbrains.jet.descriptors.serialization.NameResolver
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
import org.jetbrains.jet.descriptors.serialization.TypeDeserializer
import org.jetbrains.jet.descriptors.serialization.MemberDeserializer
import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor
import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader
public open class DeserializationGlobalContext(
public val storageManager: StorageManager,
public val descriptorFinder: DescriptorFinder,
public val annotationLoader: AnnotationLoader,
public val constantLoader: ConstantLoader,
public val packageFragmentProvider: PackageFragmentProvider
) {
public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
return DeserializationContext(storageManager, descriptorFinder, annotationLoader,
constantLoader, packageFragmentProvider, nameResolver)
}
}
public open class DeserializationContext(
storageManager: StorageManager,
descriptorFinder: DescriptorFinder,
annotationLoader: AnnotationLoader,
constantLoader: ConstantLoader,
packageFragmentProvider: PackageFragmentProvider,
public val nameResolver: NameResolver
) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
constantLoader, packageFragmentProvider) {
fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes {
val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}",
TypeDeserializer.TypeParameterResolver.NONE)
return withTypes(containingDeclaration, typeDeserializer)
}
fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes {
return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationLoader,
constantLoader, packageFragmentProvider,
nameResolver, containingDeclaration,
typeDeserializer)
}
}
class DeserializationContextWithTypes(
storageManager: StorageManager,
descriptorFinder: DescriptorFinder,
annotationLoader: AnnotationLoader,
constantLoader: ConstantLoader,
packageFragmentProvider: PackageFragmentProvider,
nameResolver: NameResolver,
val containingDeclaration: DeclarationDescriptor,
val typeDeserializer: TypeDeserializer
) : DeserializationContext(storageManager, descriptorFinder, annotationLoader,
constantLoader, packageFragmentProvider, nameResolver) {
val deserializer: MemberDeserializer = MemberDeserializer(this)
public fun childContext(
descriptor: DeclarationDescriptor,
typeParameterProtos: List<TypeParameter>,
typeParameters: MutableList<TypeParameterDescriptor>
): DeserializationContextWithTypes {
val childTypeParameterResolver = object : TypeDeserializer.TypeParameterResolver {
override fun getTypeParameters(typeDeserializer: TypeDeserializer): List<DeserializedTypeParameterDescriptor> {
val descriptors = deserializer.typeParameters(typeParameterProtos, typeDeserializer)
typeParameters.addAll(descriptors)
return descriptors
}
}
val childTypeDeserializer = TypeDeserializer(this, typeDeserializer, "Child deserializer for " + descriptor.getName(),
childTypeParameterResolver)
return withTypes(descriptor, childTypeDeserializer)
}
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright 2010-2014 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.descriptors.serialization.descriptors;
public enum AnnotatedCallableKind {
FUNCTION,
PROPERTY,
PROPERTY_GETTER,
PROPERTY_SETTER
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java → core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationLoader.java
+2 -4
View File
@@ -23,10 +23,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
public interface AnnotationDeserializer {
AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
public interface AnnotationLoader {
AnnotationLoader UNSUPPORTED = new AnnotationLoader() {
@NotNull
@Override
public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java → core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java
+2 -4
View File
@@ -23,10 +23,8 @@ import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
public interface ConstantDeserializer {
ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() {
public interface ConstantLoader {
ConstantLoader UNSUPPORTED = new ConstantLoader() {
@Nullable
@Override
public CompileTimeConstant<?> loadPropertyConstant(
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java
+39 -51
View File
@@ -22,6 +22,9 @@ import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.descriptors.serialization.*;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor;
@@ -45,21 +48,17 @@ import org.jetbrains.jet.storage.StorageManager;
import java.util.*;
import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE;
import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*;
import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName;
public class DeserializedClassDescriptor extends AbstractClassDescriptor implements ClassDescriptor {
private final ClassId classId;
private final ProtoBuf.Class classProto;
private final StorageManager storageManager;
private final TypeDeserializer typeDeserializer;
private final DescriptorDeserializer deserializer;
private final DeserializedMemberScope memberScope;
private final NullableLazyValue<ConstructorDescriptor> primaryConstructor;
private final Deserializers deserializers;
private final NotNullLazyValue<Annotations> annotations;
private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
@@ -72,33 +71,22 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
private final Visibility visibility;
private final ClassKind kind;
private final boolean isInner;
private final DescriptorFinder descriptorFinder;
private final PackageFragmentProvider packageFragmentProvider;
private final DeserializationContextWithTypes context;
public DeserializedClassDescriptor(
@NotNull StorageManager storageManager,
@NotNull Deserializers deserializers,
@NotNull DescriptorFinder descriptorFinder,
@NotNull PackageFragmentProvider packageFragmentProvider,
@NotNull NameResolver nameResolver,
@NotNull ProtoBuf.Class classProto
) {
super(storageManager, nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName());
public DeserializedClassDescriptor(@NotNull DeserializationGlobalContext globalContext, @NotNull ClassData classData) {
this(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto());
}
public DeserializedClassDescriptor(@NotNull DeserializationContext outerContext, @NotNull ProtoBuf.Class classProto) {
super(outerContext.getStorageManager(),
outerContext.getNameResolver().getClassId(classProto.getFqName()).getRelativeClassName().shortName());
this.classProto = classProto;
this.classId = nameResolver.getClassId(classProto.getFqName());
this.storageManager = storageManager;
this.packageFragmentProvider = packageFragmentProvider;
this.descriptorFinder = descriptorFinder;
this.classId = outerContext.getNameResolver().getClassId(classProto.getFqName());
TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, null, nameResolver,
descriptorFinder, "Deserializer for class " + getName(), NONE);
DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(storageManager, notNullTypeDeserializer,
this, nameResolver, deserializers);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(classProto.getTypeParameterCount());
this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParameterList(), typeParameters);
this.typeDeserializer = deserializer.getTypeDeserializer();
this.context = outerContext.withTypes(this).childContext(this, classProto.getTypeParameterList(), typeParameters);
this.containingDeclaration = storageManager.createLazyValue(new Function0<DeclarationDescriptor>() {
this.containingDeclaration = outerContext.getStorageManager().createLazyValue(new Function0<DeclarationDescriptor>() {
@Override
public DeclarationDescriptor invoke() {
return computeContainingDeclaration();
@@ -106,30 +94,29 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
});
this.typeConstructor = new DeserializedClassTypeConstructor(typeParameters);
this.memberScope = new DeserializedClassMemberScope(storageManager, this);
this.memberScope = new DeserializedClassMemberScope();
int flags = classProto.getFlags();
this.modality = DescriptorDeserializer.modality(Flags.MODALITY.get(flags));
this.visibility = DescriptorDeserializer.visibility(Flags.VISIBILITY.get(flags));
this.kind = DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(flags));
this.modality = modality(Flags.MODALITY.get(flags));
this.visibility = visibility(Flags.VISIBILITY.get(flags));
this.kind = classKind(Flags.CLASS_KIND.get(flags));
this.isInner = Flags.INNER.get(flags);
this.deserializers = deserializers;
this.annotations = storageManager.createLazyValue(new Function0<Annotations>() {
this.annotations = context.getStorageManager().createLazyValue(new Function0<Annotations>() {
@Override
public Annotations invoke() {
return computeAnnotations();
}
});
this.primaryConstructor = storageManager.createNullableLazyValue(new Function0<ConstructorDescriptor>() {
this.primaryConstructor = context.getStorageManager().createNullableLazyValue(new Function0<ConstructorDescriptor>() {
@Override
public ConstructorDescriptor invoke() {
return computePrimaryConstructor();
}
});
this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0<ClassDescriptor>() {
this.classObjectDescriptor = context.getStorageManager().createNullableLazyValue(new Function0<ClassDescriptor>() {
@Override
public ClassDescriptor invoke() {
return computeClassObjectDescriptor();
@@ -148,12 +135,13 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
@NotNull
private DeclarationDescriptor computeContainingDeclaration() {
if (classId.isTopLevelClass()) {
List<PackageFragmentDescriptor> fragments = packageFragmentProvider.getPackageFragments(classId.getPackageFqName());
List<PackageFragmentDescriptor> fragments =
context.getPackageFragmentProvider().getPackageFragments(classId.getPackageFqName());
assert fragments.size() == 1 : "there should be exactly one package: " + fragments;
return fragments.iterator().next();
}
else {
ClassOrPackageFragmentDescriptor result = descriptorFinder.findClass(classId.getOuterClassId());
ClassDescriptor result = context.getDescriptorFinder().findClass(classId.getOuterClassId());
return result != null ? result : ErrorUtils.getErrorModule();
}
}
@@ -192,7 +180,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) {
return Annotations.EMPTY;
}
return deserializers.getAnnotationDeserializer().loadClassAnnotations(this, classProto);
return context.getAnnotationLoader().loadClassAnnotations(this, classProto);
}
@NotNull
@@ -218,7 +206,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
return descriptor;
}
return (ConstructorDescriptor) deserializer.loadCallable(constructorProto.getData());
return (ConstructorDescriptor) context.getDeserializer().loadCallable(constructorProto.getData());
}
@Nullable
@@ -254,11 +242,10 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
throw new IllegalStateException("Object should have a serialized class object: " + classId);
}
return new DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider,
deserializer.getNameResolver(), classObjectProto.getData());
return new DeserializedClassDescriptor(context, classObjectProto.getData());
}
return descriptorFinder.findClass(classId.createNestedClassId(getClassObjectName(getName())));
return context.getDescriptorFinder().findClass(classId.createNestedClassId(getClassObjectName(getName())));
}
@NotNull
@@ -313,7 +300,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
private Collection<JetType> computeSuperTypes() {
List<JetType> supertypes = new ArrayList<JetType>(classProto.getSupertypeCount());
for (ProtoBuf.Type supertype : classProto.getSupertypeList()) {
supertypes.add(typeDeserializer.type(supertype));
supertypes.add(context.getTypeDeserializer().type(supertype));
}
return supertypes;
}
@@ -384,12 +371,12 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
}
}
private static class DeserializedClassMemberScope extends DeserializedMemberScope {
private class DeserializedClassMemberScope extends DeserializedMemberScope {
private final DeserializedClassDescriptor classDescriptor;
public DeserializedClassMemberScope(@NotNull StorageManager storageManager, @NotNull DeserializedClassDescriptor classDescriptor) {
super(storageManager, classDescriptor, classDescriptor.deserializer, classDescriptor.classProto.getMemberList());
this.classDescriptor = classDescriptor;
public DeserializedClassMemberScope() {
super(context, DeserializedClassDescriptor.this.classProto.getMemberList());
this.classDescriptor = DeserializedClassDescriptor.this;
}
@Override
@@ -485,6 +472,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
this.nestedClassNames = nestedClassNames();
this.enumEntryNames = enumEntryNames();
final StorageManager storageManager = context.getStorageManager();
final NotNullLazyValue<Collection<Name>> enumMemberNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
@Override
public Collection<Name> invoke() {
@@ -500,7 +488,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
.create(storageManager, DeserializedClassDescriptor.this, name, enumMemberNames);
}
if (nestedClassNames.contains(name)) {
return descriptorFinder.findClass(classId.createNestedClassId(name));
return context.getDescriptorFinder().findClass(classId.createNestedClassId(name));
}
return null;
}
@@ -510,7 +498,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
@NotNull
private Set<Name> nestedClassNames() {
Set<Name> result = new HashSet<Name>();
NameResolver nameResolver = deserializer.getNameResolver();
NameResolver nameResolver = context.getNameResolver();
for (Integer index : classProto.getNestedClassNameList()) {
result.add(nameResolver.getName(index));
}
@@ -524,7 +512,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
}
Set<Name> result = new HashSet<Name>();
NameResolver nameResolver = deserializer.getNameResolver();
NameResolver nameResolver = context.getNameResolver();
for (Integer index : classProto.getEnumEntryList()) {
result.add(nameResolver.getName(index));
}
@@ -543,7 +531,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
}
}
final NameResolver nameResolver = deserializer.getNameResolver();
final NameResolver nameResolver = context.getNameResolver();
return KotlinPackage.mapTo(classProto.getMemberList(), result, new Function1<ProtoBuf.Callable, Name>() {
@Override
public Name invoke(@NotNull ProtoBuf.Callable callable) {
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java
+25 -25
View File
@@ -21,9 +21,9 @@ import kotlin.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.ReadOnly;
import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer;
import org.jetbrains.jet.descriptors.serialization.Flags;
import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -50,24 +50,20 @@ public abstract class DeserializedMemberScope implements JetScope {
}
};
private final DeclarationDescriptor containingDeclaration;
private final DescriptorDeserializer deserializer;
private final NotNullLazyValue<Map<Name, List<ProtoBuf.Callable>>> membersProtos;
private final MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> functions;
private final MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> properties;
private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
private final DeserializationContextWithTypes context;
protected DeserializedMemberScope(
@NotNull StorageManager storageManager,
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull DescriptorDeserializer deserializer,
@NotNull DeserializationContextWithTypes context,
@NotNull final Collection<ProtoBuf.Callable> membersList
) {
this.containingDeclaration = containingDeclaration;
this.deserializer = deserializer;
this.context = context;
StorageManager storageManager = context.getStorageManager();
this.membersProtos = storageManager.createLazyValue(new Function0<Map<Name, List<ProtoBuf.Callable>>>() {
@Override
public Map<Name, List<ProtoBuf.Callable>> invoke() {
@@ -80,18 +76,22 @@ public abstract class DeserializedMemberScope implements JetScope {
return computeFunctions(name);
}
});
this.properties = storageManager.createMemoizedFunction(new Function1<Name, Collection<VariableDescriptor>>() {
@Override
public Collection<VariableDescriptor> invoke(Name name) {
return computeProperties(name);
}
});
this.allDescriptors = storageManager.createLazyValue(new Function0<Collection<DeclarationDescriptor>>() {
@Override
public Collection<DeclarationDescriptor> invoke() {
return computeAllDescriptors();
}
});
this.properties = storageManager.createMemoizedFunction(
new Function1<Name, Collection<VariableDescriptor>>() {
@Override
public Collection<VariableDescriptor> invoke(Name name) {
return computeProperties(name);
}
}
);
this.allDescriptors = storageManager.createLazyValue(
new Function0<Collection<DeclarationDescriptor>>() {
@Override
public Collection<DeclarationDescriptor> invoke() {
return computeAllDescriptors();
}
}
);
}
@NotNull
@@ -104,7 +104,7 @@ public abstract class DeserializedMemberScope implements JetScope {
private Map<Name, List<ProtoBuf.Callable>> groupByName(@NotNull Collection<ProtoBuf.Callable> membersList) {
Map<Name, List<ProtoBuf.Callable>> map = new HashMap<Name, List<ProtoBuf.Callable>>();
for (ProtoBuf.Callable memberProto : membersList) {
Name name = deserializer.getNameResolver().getName(memberProto.getName());
Name name = context.getNameResolver().getName(memberProto.getName());
List<ProtoBuf.Callable> protos = map.get(name);
if (protos == null) {
protos = new ArrayList<ProtoBuf.Callable>(1);
@@ -124,7 +124,7 @@ public abstract class DeserializedMemberScope implements JetScope {
for (ProtoBuf.Callable memberProto : memberProtos) {
if (callableKind.accept(Flags.CALLABLE_KIND.get(memberProto.getFlags()))) {
//noinspection unchecked
descriptors.add((D) deserializer.loadCallable(memberProto));
descriptors.add((D) context.getDeserializer().loadCallable(memberProto));
}
}
}
@@ -190,7 +190,7 @@ public abstract class DeserializedMemberScope implements JetScope {
@NotNull
@Override
public DeclarationDescriptor getContainingDeclaration() {
return containingDeclaration;
return context.getContainingDeclaration();
}
@NotNull
@@ -250,7 +250,7 @@ public abstract class DeserializedMemberScope implements JetScope {
p.println(getClass().getSimpleName(), " {");
p.pushIndent();
p.println("containingDeclaration = " + containingDeclaration);
p.println("containingDeclaration = " + getContainingDeclaration());
p.popIndent();
p.println("}");
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java
+19 -15
View File
@@ -18,7 +18,11 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.descriptors.serialization.*;
import org.jetbrains.jet.descriptors.serialization.ClassId;
import org.jetbrains.jet.descriptors.serialization.PackageData;
import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
@@ -26,40 +30,40 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
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.storage.StorageManager;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class DeserializedPackageMemberScope extends DeserializedMemberScope {
private final DescriptorFinder descriptorFinder;
private final FqName packageFqName;
private final DeserializationContext context;
public DeserializedPackageMemberScope(
@NotNull StorageManager storageManager,
@NotNull PackageFragmentDescriptor packageDescriptor,
@NotNull Deserializers deserializers,
@NotNull DescriptorFinder descriptorFinder,
@NotNull PackageData packageData
@NotNull ProtoBuf.Package proto,
@NotNull DeserializationContext context
) {
super(storageManager, packageDescriptor,
DescriptorDeserializer.create(storageManager, packageDescriptor, packageData.getNameResolver(), descriptorFinder, deserializers),
packageData.getPackageProto().getMemberList());
this.descriptorFinder = descriptorFinder;
super(context.withTypes(packageDescriptor), proto.getMemberList());
this.context = context;
this.packageFqName = packageDescriptor.getFqName();
}
public DeserializedPackageMemberScope(
@NotNull PackageFragmentDescriptor packageDescriptor,
@NotNull PackageData packageData,
@NotNull DeserializationGlobalContext context
) {
this(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver()));
}
@Nullable
@Override
protected ClassDescriptor getClassDescriptor(@NotNull Name name) {
return descriptorFinder.findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name)));
return context.getDescriptorFinder().findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name)));
}
@Override
protected void addAllClassDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
for (Name className : descriptorFinder.getClassNames(packageFqName)) {
for (Name className : context.getDescriptorFinder().getClassNames(packageFqName)) {
ClassDescriptor classDescriptor = getClassDescriptor(className);
if (classDescriptor != null) {
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java
+7 -10
View File
@@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer;
import org.jetbrains.jet.descriptors.serialization.Flags;
import org.jetbrains.jet.descriptors.serialization.NameResolver;
import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
import org.jetbrains.jet.descriptors.serialization.*;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
@@ -87,19 +84,19 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
public static DeserializedSimpleFunctionDescriptor create(
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull ProtoBuf.Callable proto,
@NotNull Deserializers deserializers,
@NotNull AnnotationLoader annotationLoader,
@NotNull NameResolver nameResolver
) {
Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
Deserializers.AnnotatedCallableKind.FUNCTION,
deserializers.getAnnotationDeserializer(),
nameResolver);
Annotations annotations = MemberDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
AnnotatedCallableKind.FUNCTION,
annotationLoader,
nameResolver);
return new DeserializedSimpleFunctionDescriptor(
containingDeclaration,
null,
annotations,
nameResolver.getName(proto.getName()),
DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())),
SerializationPackage.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())),
proto,
nameResolver);
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java
-48
View File
@@ -1,48 +0,0 @@
/*
* Copyright 2010-2014 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.descriptors.serialization.descriptors;
import org.jetbrains.annotations.NotNull;
public interface Deserializers {
Deserializers UNSUPPORTED = new Deserializers() {
@NotNull
@Override
public AnnotationDeserializer getAnnotationDeserializer() {
return AnnotationDeserializer.UNSUPPORTED;
}
@NotNull
@Override
public ConstantDeserializer getConstantDeserializer() {
return ConstantDeserializer.UNSUPPORTED;
}
};
@NotNull
AnnotationDeserializer getAnnotationDeserializer();
@NotNull
ConstantDeserializer getConstantDeserializer();
enum AnnotatedCallableKind {
FUNCTION,
PROPERTY,
PROPERTY_GETTER,
PROPERTY_SETTER
}
}
core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt
+68
View File
@@ -0,0 +1,68 @@
/*
* Copyright 2010-2014 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.descriptors.serialization
import org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
import org.jetbrains.jet.lang.descriptors.Modality
import org.jetbrains.jet.lang.descriptors.Visibilities
import org.jetbrains.jet.lang.descriptors.ClassKind
import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter
import org.jetbrains.jet.lang.types.Variance
fun memberKind(memberKind: Callable.MemberKind) = when (memberKind) {
ProtoBuf.Callable.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
ProtoBuf.Callable.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
ProtoBuf.Callable.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION
ProtoBuf.Callable.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED
}
fun modality(modality: ProtoBuf.Modality) = when (modality) {
ProtoBuf.Modality.FINAL -> Modality.FINAL
ProtoBuf.Modality.OPEN -> Modality.OPEN
ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT
}
fun visibility(visibility: ProtoBuf.Visibility) = when (visibility) {
ProtoBuf.Visibility.INTERNAL -> Visibilities.INTERNAL
ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE
ProtoBuf.Visibility.PROTECTED -> Visibilities.PROTECTED
ProtoBuf.Visibility.PUBLIC -> Visibilities.PUBLIC
ProtoBuf.Visibility.EXTRA -> throw UnsupportedOperationException("Extra visibilities are not supported yet")
}
public fun classKind(kind: ProtoBuf.Class.Kind): ClassKind = when (kind) {
ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS
ProtoBuf.Class.Kind.TRAIT -> ClassKind.TRAIT
ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS
ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY
ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS
ProtoBuf.Class.Kind.OBJECT -> ClassKind.OBJECT
ProtoBuf.Class.Kind.CLASS_OBJECT -> ClassKind.CLASS_OBJECT
}
fun variance(variance: TypeParameter.Variance) = when (variance) {
ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE
ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE
ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT
}
fun variance(variance: ProtoBuf.Type.Argument.Projection) = when (variance) {
ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE
ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE
ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT
}