Add serializer for compile-time constant initializer

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -61,6 +62,7 @@ public class InjectorForJavaDescriptorResolver {
     private final DescriptorDeserializers descriptorDeserializers;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
+    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
@@ -85,6 +87,7 @@ public class InjectorForJavaDescriptorResolver {
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
+        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.javaClassFinder.setProject(project);
 
@@ -105,6 +108,7 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
+        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
@@ -114,6 +118,11 @@ public class InjectorForJavaDescriptorResolver {
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
+        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+
         javaClassFinder.initialize();
 
     }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -101,6 +102,7 @@ public class InjectorForLazyResolveWithJava {
     private final DescriptorDeserializers descriptorDeserializers;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
+    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
     
     public InjectorForLazyResolveWithJava(
         @NotNull Project project,
@@ -147,6 +149,7 @@ public class InjectorForLazyResolveWithJava {
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
+        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -224,6 +227,7 @@ public class InjectorForLazyResolveWithJava {
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
+        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
@@ -233,6 +237,11 @@ public class InjectorForLazyResolveWithJava {
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
+        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+
         javaClassFinder.initialize();
 
     }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -65,6 +65,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -121,6 +122,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final DescriptorDeserializers descriptorDeserializers;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
+    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
     
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
@@ -177,6 +179,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager);
+        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -299,6 +302,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         deserializedDescriptorResolver.setStorageManager(storageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
+        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
@@ -308,6 +312,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
+        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+
         javaClassFinder.initialize();
 
     }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java

@@ -0,0 +1,49 @@
+/*
+ * 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;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.descriptors.serialization.NameResolver;
+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() {
+        @Nullable
+        @Override
+        public CompileTimeConstant<?> loadPropertyConstant(
+                @NotNull ClassOrPackageFragmentDescriptor container,
+                @NotNull ProtoBuf.Callable proto,
+                @NotNull NameResolver nameResolver,
+                @NotNull AnnotatedCallableKind kind
+        ) {
+            throw new UnsupportedOperationException("Constants are not supported");
+        }
+    };
+
+    @Nullable
+    CompileTimeConstant<?> loadPropertyConstant(
+            @NotNull ClassOrPackageFragmentDescriptor container,
+            @NotNull ProtoBuf.Callable proto,
+            @NotNull NameResolver nameResolver,
+            @NotNull AnnotatedCallableKind kind
+    );
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java

@@ -25,11 +25,20 @@ public interface Deserializers {
         public AnnotationDeserializer getAnnotationDeserializer() {
             return AnnotationDeserializer.UNSUPPORTED;
         }
+
+        @NotNull
+        @Override
+        public ConstantDeserializer getConstantDeserializer() {
+            return ConstantDeserializer.UNSUPPORTED;
+        }
     };
 
     @NotNull
     AnnotationDeserializer getAnnotationDeserializer();
 
+    @NotNull
+    ConstantDeserializer getConstantDeserializer();
+
     enum AnnotatedCallableKind {
         FUNCTION,
         PROPERTY,

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java

@@ -211,7 +211,7 @@ public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer
             return Annotations.EMPTY;
         }
 
-        List<AnnotationDescriptor> annotations = storage.getMemberAnnotations().invoke(kotlinClass).get(signature);
+        List<AnnotationDescriptor> annotations = storage.getStorage().invoke(kotlinClass).getMemberAnnotations().get(signature);
         return annotations == null ? Annotations.EMPTY : new AnnotationsImpl(annotations);
     }
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java

@@ -0,0 +1,78 @@
+/*
+ * 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.lang.resolve.kotlin;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.descriptors.serialization.NameResolver;
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
+import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer;
+import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
+
+import javax.inject.Inject;
+
+import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
+
+public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer {
+    @Inject
+    @Override
+    public void setStorage(@NotNull DescriptorDeserializersStorage storage) {
+        this.storage = storage;
+    }
+
+    @Inject
+    @Override
+    public void setClassResolver(@NotNull DependencyClassByQualifiedNameResolver classResolver) {
+        this.classResolver = classResolver;
+    }
+
+    @Inject
+    @Override
+    public void setKotlinClassFinder(@NotNull KotlinClassFinder kotlinClassFinder) {
+        this.kotlinClassFinder = kotlinClassFinder;
+    }
+
+    @Inject
+    @Override
+    public void setErrorReporter(@NotNull ErrorReporter errorReporter) {
+        this.errorReporter = errorReporter;
+    }
+
+    @Nullable
+    @Override
+    public CompileTimeConstant<?> loadPropertyConstant(
+            @NotNull ClassOrPackageFragmentDescriptor container,
+            @NotNull ProtoBuf.Callable proto,
+            @NotNull NameResolver nameResolver,
+            @NotNull AnnotatedCallableKind kind
+    ) {
+        MemberSignature signature = getCallableSignature(proto, nameResolver, kind);
+        if (signature == null) return null;
+
+        KotlinJvmBinaryClass kotlinClass = findClassWithMemberAnnotations(container, proto, nameResolver, kind);
+        if (kotlinClass == null) {
+            errorReporter.reportAnnotationLoadingError("Kotlin class for loading property constant is not found: " + container, null);
+            return null;
+        }
+
+        return storage.getStorage().invoke(kotlinClass).getPropertyConstants().get(signature);
+    }
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.kotlin;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
+import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer;
 import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
 
 import javax.inject.Inject;
@@ -25,15 +26,27 @@ import javax.inject.Inject;
 public class DescriptorDeserializers implements Deserializers {
 
     private AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private ConstantDescriptorDeserializer constantDescriptorDeserializer;
 
     @Inject
     public void setAnnotationDescriptorDeserializer(AnnotationDescriptorDeserializer annotationDescriptorDeserializer) {
         this.annotationDescriptorDeserializer = annotationDescriptorDeserializer;
     }
 
+    @Inject
+    public void setConstantDescriptorDeserializer(ConstantDescriptorDeserializer constantDescriptorDeserializer) {
+        this.constantDescriptorDeserializer = constantDescriptorDeserializer;
+    }
+
     @NotNull
     @Override
     public AnnotationDeserializer getAnnotationDeserializer() {
         return annotationDescriptorDeserializer;
     }
+
+    @NotNull
+    @Override
+    public ConstantDeserializer getConstantDeserializer() {
+        return constantDescriptorDeserializer;
+    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java

@@ -20,9 +20,11 @@ import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
+import org.jetbrains.jet.lang.resolve.java.resolver.ResolverPackage;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 import org.jetbrains.jet.storage.MemoizedFunctionToNotNull;
@@ -36,21 +38,21 @@ public class DescriptorDeserializersStorage {
     private DependencyClassByQualifiedNameResolver classResolver;
     private ErrorReporter errorReporter;
 
-    private final MemoizedFunctionToNotNull<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>> memberAnnotations;
+    private final MemoizedFunctionToNotNull<KotlinJvmBinaryClass, Storage> storage;
 
     public DescriptorDeserializersStorage(@NotNull StorageManager storageManager) {
-        this.memberAnnotations = storageManager.createMemoizedFunction(
+        this.storage = storageManager.createMemoizedFunction(
-                new Function1<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>>() {
+                new Function1<KotlinJvmBinaryClass, Storage>() {
                     @NotNull
                     @Override
-                    public Map<MemberSignature, List<AnnotationDescriptor>> invoke(@NotNull KotlinJvmBinaryClass kotlinClass) {
+                    public Storage invoke(@NotNull KotlinJvmBinaryClass kotlinClass) {
                         try {
                             return loadMemberAnnotationsFromClass(kotlinClass);
                         }
                         catch (IOException e) {
                             errorReporter.reportAnnotationLoadingError(
                                     "Error loading member annotations from Kotlin class: " + kotlinClass, e);
-                            return Collections.emptyMap();
+                            return Storage.EMPTY;
                         }
                     }
                 });
@@ -67,15 +69,14 @@ public class DescriptorDeserializersStorage {
     }
 
     @NotNull
-    public MemoizedFunctionToNotNull<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>> getMemberAnnotations() {
+    protected MemoizedFunctionToNotNull<KotlinJvmBinaryClass, Storage> getStorage() {
-        return memberAnnotations;
+        return storage;
     }
 
     @NotNull
-    protected Map<MemberSignature, List<AnnotationDescriptor>> loadMemberAnnotationsFromClass(@NotNull KotlinJvmBinaryClass kotlinClass)
+    private Storage loadMemberAnnotationsFromClass(@NotNull KotlinJvmBinaryClass kotlinClass) throws IOException {
-            throws IOException {
+        final Map<MemberSignature, List<AnnotationDescriptor>> memberAnnotations = new HashMap<MemberSignature, List<AnnotationDescriptor>>();
-        final Map<MemberSignature, List<AnnotationDescriptor>> memberAnnotations =
+        final Map<MemberSignature, CompileTimeConstant<?>> propertyConstants = new HashMap<MemberSignature, CompileTimeConstant<?>>();
-                new HashMap<MemberSignature, List<AnnotationDescriptor>>();
 
         kotlinClass.loadMemberAnnotations(new KotlinJvmBinaryClass.MemberVisitor() {
             @Nullable
@@ -131,7 +132,7 @@ public class DescriptorDeserializersStorage {
             }
         });
 
-        return memberAnnotations;
+        return new Storage(memberAnnotations, propertyConstants);
     }
 
     // The purpose of this class is to hold a unique signature of either a method or a field, so that annotations on a member can be put
@@ -173,4 +174,30 @@ public class DescriptorDeserializersStorage {
             return signature;
         }
     }
+
+    protected static class Storage {
+        private final Map<MemberSignature, List<AnnotationDescriptor>> memberAnnotations;
+        private final Map<MemberSignature, CompileTimeConstant<?>> propertyConstants;
+
+        public static final Storage EMPTY = new Storage(
+                Collections.<MemberSignature, List<AnnotationDescriptor>>emptyMap(),
+                Collections.<MemberSignature, CompileTimeConstant<?>>emptyMap()
+        );
+
+        public Storage(
+                @NotNull Map<MemberSignature, List<AnnotationDescriptor>> annotations,
+                @NotNull Map<MemberSignature, CompileTimeConstant<?>> constants
+        ) {
+            this.memberAnnotations = annotations;
+            this.propertyConstants = constants;
+        }
+
+        public Map<MemberSignature, List<AnnotationDescriptor>> getMemberAnnotations() {
+            return memberAnnotations;
+        }
+
+        public Map<MemberSignature, CompileTimeConstant<?>> getPropertyConstants() {
+            return propertyConstants;
+        }
+    }
 }

idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt

@@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer
 
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -115,9 +116,21 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         annotationDeserializer.setStorage(deserializerStorage)
     }
 
+    private val constantDeserializer = ConstantDescriptorDeserializer();
+    {
+        constantDeserializer.setClassResolver {
+            fqName ->
+            classes(fqName.toClassId())
+        }
+        constantDeserializer.setKotlinClassFinder(localClassFinder)
+        constantDeserializer.setErrorReporter(LOGGING_REPORTER)
+        constantDeserializer.setStorage(deserializerStorage)
+    }
+
     private val deserializers = DescriptorDeserializers();
     {
         deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer)
+        deserializers.setConstantDescriptorDeserializer(constantDeserializer)
     }
 
     private val descriptorFinder = object : DescriptorFinder {