From 04e9e953c383fe686503c9bc6199ad735d94ba37 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Fri, 28 Jun 2013 21:07:22 +0400 Subject: [PATCH] Initial version of deserialization of compiled kotlin classes Annotations are not supported --- compiler/frontend.java/frontend.java.iml | 1 + .../di/InjectorForJavaDescriptorResolver.java | 7 + .../di/InjectorForJavaSemanticServices.java | 7 + .../di/InjectorForTopDownAnalyzerForJvm.java | 7 + .../DeserializedDescriptorResolver.java | 291 ++++++++++++++++++ .../java/resolver/JavaClassResolver.java | 16 +- .../serialization/AbstractClassResolver.java | 18 +- .../descriptors/serialization/ClassId.java | 30 ++ .../AbstractDescriptorSerializationTest.java | 42 +-- 9 files changed, 377 insertions(+), 42 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java diff --git a/compiler/frontend.java/frontend.java.iml b/compiler/frontend.java/frontend.java.iml index 689b119f411..b979014c075 100644 --- a/compiler/frontend.java/frontend.java.iml +++ b/compiler/frontend.java/frontend.java.iml @@ -12,6 +12,7 @@ + diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index f0a15388e43..ef2bf2ad065 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; @@ -60,6 +61,7 @@ public class InjectorForJavaDescriptorResolver { private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; + private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final JavaNamespaceResolver javaNamespaceResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; @@ -87,6 +89,7 @@ public class InjectorForJavaDescriptorResolver { this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); + this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.javaNamespaceResolver = new JavaNamespaceResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); @@ -115,6 +118,7 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -147,6 +151,9 @@ public class InjectorForJavaDescriptorResolver { javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); + deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver); + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 1d045b66f02..afabcf0b8ab 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; @@ -60,6 +61,7 @@ public class InjectorForJavaSemanticServices { private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; + private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final JavaNamespaceResolver javaNamespaceResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; @@ -85,6 +87,7 @@ public class InjectorForJavaSemanticServices { this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); + this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.javaNamespaceResolver = new JavaNamespaceResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); @@ -115,6 +118,7 @@ public class InjectorForJavaSemanticServices { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -147,6 +151,9 @@ public class InjectorForJavaSemanticServices { javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); + deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver); + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 63b92638dfc..976d741e2ce 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; @@ -110,6 +111,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; + private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final JavaNamespaceResolver javaNamespaceResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; @@ -163,6 +165,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); + this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.javaNamespaceResolver = new JavaNamespaceResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); @@ -293,6 +296,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -325,6 +329,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); + deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver); + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java new file mode 100644 index 00000000000..54e60b7e813 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java @@ -0,0 +1,291 @@ +/* + * Copyright 2010-2013 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.resolve.java.resolver; + +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiClass; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.asm4.AnnotationVisitor; +import org.jetbrains.asm4.ClassReader; +import org.jetbrains.asm4.ClassVisitor; +import org.jetbrains.asm4.Opcodes; +import org.jetbrains.jet.descriptors.serialization.*; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager; +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.types.lang.KotlinBuiltIns; + +import javax.inject.Inject; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import static org.jetbrains.asm4.ClassReader.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN; + +public final class DeserializedDescriptorResolver { + + private static final Logger LOG = Logger.getInstance(DeserializedDescriptorResolver.class); + private static final String KOTLIN_INFO_TYPE = JvmStdlibNames.KOTLIN_INFO_CLASS.getAsmType().toString(); + + public static final AnnotationDeserializer DUMMY_ANNOTATION_DESERIALIZER = new AnnotationDeserializer() { + @NotNull + @Override + public List loadClassAnnotations(@NotNull ProtoBuf.Class classProto) { + // This is a hack for tests: only data annotations are present in test data so far + AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor(); + annotationDescriptor.setAnnotationType(KotlinBuiltIns.getInstance().getDataClassAnnotation().getDefaultType()); + return Collections.singletonList(annotationDescriptor); + } + + @NotNull + @Override + public List loadCallableAnnotations(@NotNull ProtoBuf.Callable callableProto) { + throw new UnsupportedOperationException(); // TODO + } + + @NotNull + @Override + public List loadSetterAnnotations(@NotNull ProtoBuf.Callable callableProto) { + throw new UnsupportedOperationException(); // TODO + } + + @NotNull + @Override + public List loadValueParameterAnnotations(@NotNull ProtoBuf.Callable.ValueParameter parameterProto) { + throw new UnsupportedOperationException(); // TODO + } + }; + + @NotNull + private final LockBasedStorageManager storageManager = new LockBasedStorageManager(); + + private JavaNamespaceResolver javaNamespaceResolver; + + private JavaClassResolver javaClassResolver; + + @Inject + public void setJavaNamespaceResolver(JavaNamespaceResolver javaNamespaceResolver) { + this.javaNamespaceResolver = javaNamespaceResolver; + } + + @Inject + public void setJavaClassResolver(JavaClassResolver javaClassResolver) { + this.javaClassResolver = javaClassResolver; + } + + @Nullable + public ClassDescriptor resolveClass( + @NotNull FqName fqName, + @NotNull PsiClass psiClass, + @NotNull ClassOrNamespaceDescriptor containingDeclaration + ) { + VirtualFile virtualFile = getVirtualFile(psiClass, fqName, containingDeclaration); + if (virtualFile == null) { + return null; + } + ClassData classData = readClassDataFromClassFile(virtualFile); + if (classData == null) { + return null; + } + return deserializeClass(classData, fqName, containingDeclaration); + } + + @Nullable + private static VirtualFile getVirtualFile( + @NotNull PsiClass psiClass, + @NotNull FqName classFqName, + @NotNull ClassOrNamespaceDescriptor containingDeclaration + ) { + VirtualFile mostOuterClassVirtualFile = psiClass.getContainingFile().getVirtualFile(); + if (mostOuterClassVirtualFile == null) { + LOG.error("No virtual file for " + psiClass.getQualifiedName()); + return null; + } + String fileExtension = mostOuterClassVirtualFile.getExtension(); + if (fileExtension == null || !fileExtension.equals("class")) { + return null; + } + ClassId id = ClassId.fromFqNameAndContainingDeclaration(classFqName, containingDeclaration); + FqNameUnsafe relativeClassName = id.getRelativeClassName(); + assert relativeClassName.isSafe() : "Relative class name " + relativeClassName.asString() + " should be safe at this point"; + String classNameWithBucks = relativeClassName.asString().replace(".", "$") + ".class"; + VirtualFile virtualFile = mostOuterClassVirtualFile.getParent().findChild(classNameWithBucks); + if (virtualFile == null) { + LOG.error("No virtual file for " + psiClass.getQualifiedName()); + return null; + } + return virtualFile; + } + + @Nullable + private ClassDescriptor deserializeClass( + @NotNull ClassData classData, + @NotNull FqName fqName, + @NotNull ClassOrNamespaceDescriptor containingDeclaration + ) { + ClassId classId = ClassId.fromFqNameAndContainingDeclaration(fqName, containingDeclaration); + AbstractClassResolver classResolver = + new DeserializedClassResolver(storageManager, DUMMY_ANNOTATION_DESERIALIZER, classId, classData); + ClassDescriptor classDescriptor = classResolver.findClassInternally(classId); + assert classDescriptor != null : "Could not correctly deserialize class " + fqName.asString(); + return classDescriptor; + } + + @Nullable + private static ClassData readClassDataFromClassFile(@NotNull VirtualFile virtualFile) { + try { + InputStream inputStream = virtualFile.getInputStream(); + try { + ClassReader reader = new ClassReader(inputStream); + GetKotlinInfoDataVisitor visitor = new GetKotlinInfoDataVisitor(); + reader.accept(visitor, SKIP_CODE | SKIP_FRAMES | SKIP_DEBUG); + return visitor.getClassData(); + } + finally { + inputStream.close(); + } + } + catch (IOException e) { + LOG.error(e); + } + return null; + } + + private static class GetKotlinInfoDataVisitor extends ClassVisitor { + public GetKotlinInfoDataVisitor() { + super(Opcodes.ASM4); + } + + @Nullable + private byte[] data = null; + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + if (!desc.equals(KOTLIN_INFO_TYPE)) { + return null; + } + return new AnnotationVisitor(Opcodes.ASM4) { + @Override + public void visit(String name, Object value) { + if (name.equals("data")) { + data = (byte[]) value; + } + else { + LOG.error("Unexpected property " + name + " for annotation " + KOTLIN_INFO_TYPE); + } + } + }; + } + + @Nullable + private ClassData getClassData() { + if (data == null) { + return null; + } + return ClassSerializationUtil.readClassDataFrom(data); + } + } + + @NotNull + private static FqName kotlinFqNameToJavaFqName(@NotNull FqNameUnsafe kotlinFqName) { + List correctedSegments = new ArrayList(); + for (Name segment : kotlinFqName.pathSegments()) { + if (segment.asString().startsWith(" fullNameSegments = fqName.pathSegments(); + FqName namespaceFqName = DescriptorUtils.getFQName(containingNamespace).toSafe(); + List namespaceNameSegments = namespaceFqName.pathSegments(); + for (int i = 0; i < namespaceNameSegments.size(); ++i) { + assert fullNameSegments.get(i).equals(namespaceNameSegments.get(i)); + } + List relativeNameSegments = fullNameSegments.subList(namespaceNameSegments.size(), fullNameSegments.size()); + FqName relativeFqName = FqName.fromSegments(ContainerUtil.map2List(relativeNameSegments, new Function() { + @Override + public String fun(Name name) { + return name.asString(); + } + })); + return new ClassId(namespaceFqName, relativeFqName.toUnsafe()); + } + public ClassId(@NotNull FqName packageFqName, @NotNull FqNameUnsafe relativeClassName) { this.packageFqName = packageFqName; assert !relativeClassName.isRoot() : "Class name must not be root. " + packageFqName; diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java index d51ae06d7eb..640bb4de098 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java @@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.lang.descriptors.*; @@ -39,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; @@ -51,7 +51,6 @@ 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.lang.KotlinBuiltIns; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.*; @@ -79,41 +78,6 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith } }; - public static final AnnotationDeserializer DUMMY_ANNOTATION_DESERIALIZER = new AnnotationDeserializer() { - @NotNull - @Override - public List loadClassAnnotations( - @NotNull ProtoBuf.Class classProto - ) { - // This is a hack for tests: only data annotations are present in test data so far - AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor(); - annotationDescriptor.setAnnotationType(KotlinBuiltIns.getInstance().getDataClassAnnotation().getDefaultType()); - return Collections.singletonList(annotationDescriptor); - } - - @NotNull - @Override - public List loadCallableAnnotations( - @NotNull ProtoBuf.Callable callableProto - ) { - throw new UnsupportedOperationException(); // TODO - } - - @NotNull - @Override - public List loadSetterAnnotations(@NotNull ProtoBuf.Callable callableProto) { - throw new UnsupportedOperationException(); // TODO - } - - @NotNull - @Override - public List loadValueParameterAnnotations( - @NotNull ProtoBuf.Callable.ValueParameter parameterProto - ) { - throw new UnsupportedOperationException(); // TODO - } - }; - @Override protected JetCoreEnvironment createEnvironment() { return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY); @@ -400,8 +364,8 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith }; NameResolver nameResolver = new NameResolver(classMetadata.simpleNames, classMetadata.qualifiedNames); - return new DeserializedClassDescriptor(new LockBasedStorageManager(), containingDeclaration, nameResolver, DUMMY_ANNOTATION_DESERIALIZER, - this, nestedClassResolver, classMetadata.classProto, null); + return new DeserializedClassDescriptor(new LockBasedStorageManager(), containingDeclaration, nameResolver, + DeserializedDescriptorResolver.DUMMY_ANNOTATION_DESERIALIZER, this, nestedClassResolver, classMetadata.classProto, null); } @Nullable