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

build.xml

@@ -125,7 +125,6 @@
     <target name="init">
         <mkdir dir="${kotlin-home}"/>
         <mkdir dir="${kotlin-home}/lib"/>
-        <mkdir dir="${kotlin-home}/lib/tools"/>
     </target>
 
     <target name="prepareDist">

compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.codegen;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
@@ -30,7 +29,6 @@ import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetModifierList;
 import org.jetbrains.jet.lang.psi.JetModifierListOwner;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
@@ -38,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.org.objectweb.asm.*;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -46,7 +45,34 @@ import java.util.*;
 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration;
 
 public abstract class AnnotationCodegen {
-    public static final FqName VOLATILE_FQ_NAME = new FqName("kotlin.volatile");
+
+    public static final class JvmFlagAnnotation {
+        private final FqName fqName;
+        private final int jvmFlag;
+
+        public JvmFlagAnnotation(@NotNull String fqName, int jvmFlag) {
+            this.fqName = new FqName(fqName);
+            this.jvmFlag = jvmFlag;
+        }
+
+        public boolean hasAnnotation(@NotNull Annotated annotated) {
+            return annotated.getAnnotations().findAnnotation(fqName) != null;
+        }
+
+        public int getJvmFlag() {
+            return jvmFlag;
+        }
+    }
+
+    public static final List<JvmFlagAnnotation> FIELD_FLAGS = Arrays.asList(
+            new JvmFlagAnnotation("kotlin.jvm.volatile", Opcodes.ACC_VOLATILE),
+            new JvmFlagAnnotation("kotlin.jvm.transient", Opcodes.ACC_TRANSIENT)
+    );
+
+    public static final List<JvmFlagAnnotation> METHOD_FLAGS = Arrays.asList(
+            new JvmFlagAnnotation("kotlin.jvm.strictfp", Opcodes.ACC_STRICT),
+            new JvmFlagAnnotation("kotlin.jvm.synchronized", Opcodes.ACC_SYNCHRONIZED)
+    );
 
     private static final AnnotationVisitor NO_ANNOTATION_VISITOR = new AnnotationVisitor(Opcodes.ASM5) {};
 
@@ -91,7 +117,6 @@ public abstract class AnnotationCodegen {
 
             AnnotationDescriptor annotationDescriptor = bindingContext.get(BindingContext.ANNOTATION, annotationEntry);
             if (annotationDescriptor == null) continue; // Skipping annotations if they are not resolved. Needed for JetLightClass generation
-            if (isVolatile(annotationDescriptor)) continue;
 
             String descriptor = genAnnotation(annotationDescriptor);
             if (descriptor != null) {
@@ -149,11 +174,6 @@ public abstract class AnnotationCodegen {
         return !type.isNullable() && classifier instanceof TypeParameterDescriptor && TypeUtils.hasNullableSuperType(type);
     }
 
-    private static boolean isVolatile(@NotNull AnnotationDescriptor annotationDescriptor) {
-        ClassifierDescriptor classDescriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor();
-        return classDescriptor != null && DescriptorUtils.getFqName(classDescriptor).equals(VOLATILE_FQ_NAME.toUnsafe());
-    }
-
     public void generateAnnotationDefaultValue(@NotNull CompileTimeConstant value, @NotNull JetType expectedType) {
         AnnotationVisitor visitor = visitAnnotation(null, false);  // Parameters are unimportant
         genCompileTimeValue(null, value, expectedType, visitor);

compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java

@@ -169,6 +169,12 @@ public class AsmUtil {
     public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind) {
         int flags = getCommonCallableFlags(functionDescriptor);
 
+        for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) {
+            if (flagAnnotation.hasAnnotation(functionDescriptor.getOriginal())) {
+                flags |= flagAnnotation.getJvmFlag();
+            }
+        }
+
         if (functionDescriptor.getModality() == Modality.FINAL && !(functionDescriptor instanceof ConstructorDescriptor)) {
             DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration();
             if (!(containingDeclaration instanceof ClassDescriptor) ||

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -189,8 +189,10 @@ public class PropertyCodegen {
     private FieldVisitor generateBackingField(JetNamedDeclaration element, PropertyDescriptor propertyDescriptor, boolean isDelegate, JetType jetType, Object defaultValue) {
         int modifiers = getDeprecatedAccessFlag(propertyDescriptor);
 
-        if (propertyDescriptor.getOriginal().getAnnotations().findAnnotation(AnnotationCodegen.VOLATILE_FQ_NAME) != null) {
+        for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.FIELD_FLAGS) {
-            modifiers |= ACC_VOLATILE;
+            if (flagAnnotation.hasAnnotation(propertyDescriptor.getOriginal())) {
+                modifiers |= flagAnnotation.getJvmFlag();
+            }
         }
 
         if (kind == OwnerKind.PACKAGE) {

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

@@ -33,10 +33,11 @@ import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -61,10 +62,11 @@ public class InjectorForJavaDescriptorResolver {
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final JavaDescriptorFinder javaDescriptorFinder;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
@@ -87,10 +89,11 @@ public class InjectorForJavaDescriptorResolver {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.javaClassFinder.setProject(project);
 
@@ -105,27 +108,21 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
-        descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 

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

@@ -55,10 +55,11 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -105,10 +106,11 @@ public class InjectorForLazyResolveWithJava {
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final JavaDescriptorFinder javaDescriptorFinder;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForLazyResolveWithJava(
         @NotNull Project project,
@@ -155,10 +157,11 @@ public class InjectorForLazyResolveWithJava {
         this.jetImportsFactory = new JetImportsFactory();
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.scriptBodyResolver = new ScriptBodyResolver();
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -235,27 +238,21 @@ public class InjectorForLazyResolveWithJava {
 
         scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
-        descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 

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

@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
@@ -59,16 +59,17 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
-import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -86,7 +87,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final JavaDescriptorResolver javaDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
@@ -119,16 +120,17 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final DeclarationResolver declarationResolver;
     private final ImportsResolver importsResolver;
     private final JetImportsFactory jetImportsFactory;
-    private final ScriptHeaderResolver scriptHeaderResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final JavaDescriptorFinder javaDescriptorFinder;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
@@ -157,7 +159,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor());
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -182,13 +187,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.declarationResolver = new DeclarationResolver();
         this.importsResolver = new ImportsResolver();
         this.jetImportsFactory = new JetImportsFactory();
-        this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager);
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -208,9 +211,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
-        this.descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
-        this.descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
-
         javaClassFinder.setProject(project);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
@@ -296,7 +296,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
-        declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);
         declarationResolver.setTrace(bindingTrace);
 
         importsResolver.setImportsFactory(jetImportsFactory);
@@ -306,9 +305,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         jetImportsFactory.setProject(project);
 
-        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        scriptHeaderResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);
@@ -319,24 +315,24 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
+        scriptHeaderResolver.setTrace(bindingTrace);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(storageManager);
 
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 
@@ -362,8 +358,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         return this.javaDescriptorResolver;
     }
     
-    public DescriptorDeserializers getDescriptorDeserializers() {
+    public DeserializationGlobalContextForJava getDeserializationGlobalContextForJava() {
-        return this.descriptorDeserializers;
+        return this.deserializationGlobalContextForJava;
     }
     
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java

@@ -56,6 +56,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
     public static final List<ImportPath> DEFAULT_IMPORTS = ImmutableList.of(
             new ImportPath("java.lang.*"),
             new ImportPath("kotlin.*"),
+            new ImportPath("kotlin.jvm.*"),
             new ImportPath("kotlin.io.*"),
             new ImportPath("kotlin.reflect.*")
     );
@@ -153,7 +154,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                     module.addFragmentProvider(
                             DependencyKind.SOURCES,
                             new IncrementalPackageFragmentProvider(
-                                    files, module, globalContext.getStorageManager(), injector.getDescriptorDeserializers(),
+                                    files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
                                     incrementalCache, moduleId, injector.getJavaDescriptorResolver()
                             )
                     );

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/PackagePartClassUtils.java

@@ -72,6 +72,6 @@ public class PackagePartClassUtils {
     @NotNull
     public static FqName getPackagePartFqName(@NotNull DeserializedCallableMemberDescriptor callable) {
         FqName packageFqName = ((PackageFragmentDescriptor) callable.getContainingDeclaration()).getFqName();
-        return packageFqName.child(BaseDescriptorDeserializer.getPackagePartClassName(callable));
+        return packageFqName.child(BaseDescriptorLoader.getPackagePartClassName(callable));
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope
-import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers
 import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
@@ -45,12 +44,13 @@ import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf
 import org.jetbrains.jet.lang.resolve.java.JvmClassName
 import org.jetbrains.jet.descriptors.serialization.PackageData
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava
 
 public class IncrementalPackageFragmentProvider(
         sourceFiles: Collection<JetFile>,
         val module: ModuleDescriptor,
         val storageManager: StorageManager,
-        val deserializers: Deserializers,
+        val deserializationContext: DeserializationGlobalContextForJava,
         val incrementalCache: IncrementalCache,
         val moduleId: String,
         val javaDescriptorResolver: JavaDescriptorResolver
@@ -124,7 +124,7 @@ public class IncrementalPackageFragmentProvider(
         }
 
         private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope(
-                storageManager, this@IncrementalPackageFragment, deserializers, descriptorFinder, packageData
+                this@IncrementalPackageFragment, packageData, deserializationContext
         ) {
             override fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> {
                 return allMemberProtos

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

@@ -49,10 +49,10 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
-import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -93,10 +93,10 @@ public class InjectorForTopDownAnalyzerBasic {
     private final DeclarationResolver declarationResolver;
     private final ImportsResolver importsResolver;
     private final JetImportsFactory jetImportsFactory;
-    private final ScriptHeaderResolver scriptHeaderResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
     
     public InjectorForTopDownAnalyzerBasic(
         @NotNull Project project,
@@ -137,10 +137,10 @@ public class InjectorForTopDownAnalyzerBasic {
         this.declarationResolver = new DeclarationResolver();
         this.importsResolver = new ImportsResolver();
         this.jetImportsFactory = new JetImportsFactory();
-        this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -232,7 +232,6 @@ public class InjectorForTopDownAnalyzerBasic {
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
-        declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);
         declarationResolver.setTrace(bindingTrace);
 
         importsResolver.setImportsFactory(jetImportsFactory);
@@ -242,9 +241,6 @@ public class InjectorForTopDownAnalyzerBasic {
 
         jetImportsFactory.setProject(project);
 
-        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        scriptHeaderResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);
@@ -255,6 +251,9 @@ public class InjectorForTopDownAnalyzerBasic {
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
     }
     
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java

@@ -93,7 +93,7 @@ public abstract class JetStubElementType<StubT extends StubElement, PsiT extends
     @Override
     public boolean shouldCreateStub(ASTNode node) {
         PsiElement psi = node.getPsi();
-        if (ArrayUtil.contains(psi.getClass(), ALWAYS_CREATE_STUB_FOR)) {
+        if (ArrayUtil.contains(psi.getClass(), (Object[]) ALWAYS_CREATE_STUB_FOR)) {
             return true;
         }
         if (psi instanceof JetDeclaration) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java

@@ -45,6 +45,7 @@ import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.REDECLARATION;
+import static org.jetbrains.jet.lang.resolve.ScriptHeaderResolver.resolveScriptDeclarations;
 
 public class DeclarationResolver {
     @NotNull
@@ -54,8 +55,6 @@ public class DeclarationResolver {
     @NotNull
     private DescriptorResolver descriptorResolver;
     @NotNull
-    private ScriptHeaderResolver scriptHeaderResolver;
-    @NotNull
     private BindingTrace trace;
 
 
@@ -79,13 +78,6 @@ public class DeclarationResolver {
         this.trace = trace;
     }
 
-    // SCRIPT: inject script header resolver
-    @Inject
-    public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) {
-        this.scriptHeaderResolver = scriptHeaderResolver;
-    }
-
-
 
     public void process(@NotNull TopDownAnalysisContext c) {
         resolveAnnotationConstructors(c);
@@ -94,7 +86,7 @@ public class DeclarationResolver {
         resolveFunctionAndPropertyHeaders(c);
 
         // SCRIPT: Resolve script declarations
-        scriptHeaderResolver.resolveScriptDeclarations(c);
+        resolveScriptDeclarations(c);
 
         createFunctionsForDataClasses(c);
         importsResolver.processMembersImports(c);

compiler/testData/builtin-classes.txt

@@ -141,6 +141,7 @@ public final class ByteProgression : kotlin.Progression<kotlin.Byte> {
         public open override /*1*/ fun <get-increment>(): kotlin.Int
     public open override /*1*/ val start: kotlin.Byte
         public open override /*1*/ fun <get-start>(): kotlin.Byte
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.ByteIterator
 }
 
@@ -170,6 +171,7 @@ public final class ByteRange : kotlin.Range<kotlin.Byte>, kotlin.Progression<kot
     public open override /*2*/ val start: kotlin.Byte
         public open override /*2*/ fun <get-start>(): kotlin.Byte
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Byte): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.ByteIterator
     
     public class object <class-object-for-ByteRange> {
@@ -259,6 +261,7 @@ public final class CharProgression : kotlin.Progression<kotlin.Char> {
         public open override /*1*/ fun <get-increment>(): kotlin.Int
     public open override /*1*/ val start: kotlin.Char
         public open override /*1*/ fun <get-start>(): kotlin.Char
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.CharIterator
 }
 
@@ -288,6 +291,7 @@ public final class CharRange : kotlin.Range<kotlin.Char>, kotlin.Progression<kot
     public open override /*2*/ val start: kotlin.Char
         public open override /*2*/ fun <get-start>(): kotlin.Char
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Char): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.CharIterator
     
     public class object <class-object-for-CharRange> {
@@ -404,6 +408,7 @@ public final class DoubleProgression : kotlin.Progression<kotlin.Double> {
         public open override /*1*/ fun <get-increment>(): kotlin.Double
     public open override /*1*/ val start: kotlin.Double
         public open override /*1*/ fun <get-start>(): kotlin.Double
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.DoubleIterator
 }
 
@@ -430,6 +435,7 @@ public final class DoubleRange : kotlin.Range<kotlin.Double>, kotlin.Progression
     public open override /*2*/ val start: kotlin.Double
         public open override /*2*/ fun <get-start>(): kotlin.Double
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Double): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.DoubleIterator
     
     public class object <class-object-for-DoubleRange> {
@@ -627,6 +633,7 @@ public final class FloatProgression : kotlin.Progression<kotlin.Float> {
         public open override /*1*/ fun <get-increment>(): kotlin.Float
     public open override /*1*/ val start: kotlin.Float
         public open override /*1*/ fun <get-start>(): kotlin.Float
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.FloatIterator
 }
 
@@ -653,6 +660,7 @@ public final class FloatRange : kotlin.Range<kotlin.Float>, kotlin.Progression<k
     public open override /*2*/ val start: kotlin.Float
         public open override /*2*/ fun <get-start>(): kotlin.Float
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Float): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.FloatIterator
     
     public class object <class-object-for-FloatRange> {
@@ -887,6 +895,7 @@ public final class IntProgression : kotlin.Progression<kotlin.Int> {
         public open override /*1*/ fun <get-increment>(): kotlin.Int
     public open override /*1*/ val start: kotlin.Int
         public open override /*1*/ fun <get-start>(): kotlin.Int
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.IntIterator
 }
 
@@ -916,6 +925,7 @@ public final class IntRange : kotlin.Range<kotlin.Int>, kotlin.Progression<kotli
     public open override /*2*/ val start: kotlin.Int
         public open override /*2*/ fun <get-start>(): kotlin.Int
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Int): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.IntIterator
     
     public class object <class-object-for-IntRange> {
@@ -1054,6 +1064,7 @@ public final class LongProgression : kotlin.Progression<kotlin.Long> {
         public open override /*1*/ fun <get-increment>(): kotlin.Long
     public open override /*1*/ val start: kotlin.Long
         public open override /*1*/ fun <get-start>(): kotlin.Long
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.LongIterator
 }
 
@@ -1083,6 +1094,7 @@ public final class LongRange : kotlin.Range<kotlin.Long>, kotlin.Progression<kot
     public open override /*2*/ val start: kotlin.Long
         public open override /*2*/ fun <get-start>(): kotlin.Long
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Long): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.LongIterator
     
     public class object <class-object-for-LongRange> {
@@ -1245,6 +1257,7 @@ public trait Range</*0*/ T : kotlin.Comparable<T>> {
     public abstract val start: T
         public abstract fun <get-start>(): T
     public abstract fun contains(/*0*/ item: T): kotlin.Boolean
+    public open fun isEmpty(): kotlin.Boolean
 }
 
 public trait Set</*0*/ out E> : kotlin.Collection<E> {
@@ -1345,6 +1358,7 @@ public final class ShortProgression : kotlin.Progression<kotlin.Short> {
         public open override /*1*/ fun <get-increment>(): kotlin.Int
     public open override /*1*/ val start: kotlin.Short
         public open override /*1*/ fun <get-start>(): kotlin.Short
+    public final fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.ShortIterator
 }
 
@@ -1374,6 +1388,7 @@ public final class ShortRange : kotlin.Range<kotlin.Short>, kotlin.Progression<k
     public open override /*2*/ val start: kotlin.Short
         public open override /*2*/ fun <get-start>(): kotlin.Short
     public open override /*1*/ fun contains(/*0*/ item: kotlin.Short): kotlin.Boolean
+    public open override /*1*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ fun iterator(): kotlin.ShortIterator
     
     public class object <class-object-for-ShortRange> {

compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt

@@ -0,0 +1,21 @@
+import java.lang.reflect.Modifier
+
+class C {
+    volatile var vol = 1
+    transient val tra = 1
+
+    strictfp fun str() {}
+    synchronized fun sync() {}
+}
+
+fun box(): String {
+    val c = javaClass<C>()
+
+    if (c.getDeclaredField("vol").getModifiers() and Modifier.VOLATILE == 0) return "Fail: volatile"
+    if (c.getDeclaredField("tra").getModifiers() and Modifier.TRANSIENT == 0) return "Fail: transient"
+
+    if (c.getDeclaredMethod("str").getModifiers() and Modifier.STRICT == 0) return "Fail: strict"
+    if (c.getDeclaredMethod("sync").getModifiers() and Modifier.SYNCHRONIZED == 0) return "Fail: synchronized"
+
+    return "OK"
+}

compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt

@@ -0,0 +1,10 @@
+volatile var vol = 1
+transient val tra = 1
+
+strictfp fun str() {}
+synchronized fun sync() {}
+
+// 0 kotlin/jvm/volatile
+// 0 kotlin/jvm/transient
+// 0 kotlin/jvm/strictfp
+// 0 kotlin/jvm/synchronized

compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt

@@ -1,3 +0,0 @@
-volatile val foo: Int = 1
-
-// 0 kotlin/volatile

compiler/testData/loadJava/compiledJava/PrivateMembers.java

@@ -0,0 +1,30 @@
+package test;
+
+public class PrivateMembers {
+    private PrivateMembers() {
+    }
+
+    private int field = 1;
+    private static int staticField = 2;
+
+    private void method() {
+    }
+
+    private void samAdapter(SamInterface r) {
+    }
+
+    private static void staticMethod() {
+    }
+
+    private class Inner {
+    }
+
+    private interface SamInterface {
+        void foo();
+    }
+
+    private static class Nested {
+        private static void staticMethodInNested() {
+        }
+    }
+}

compiler/testData/loadJava/compiledJava/PrivateMembers.txt

@@ -0,0 +1,31 @@
+package test
+
+public open class PrivateMembers : java.lang.Object {
+    private constructor PrivateMembers()
+    private final var field: kotlin.Int
+    private open fun method(): kotlin.Unit
+    private final /*synthesized*/ fun samAdapter(/*0*/ p0: (() -> kotlin.Unit)?): kotlin.Unit
+    private open fun samAdapter(/*0*/ p0: test.PrivateMembers.SamInterface?): kotlin.Unit
+
+    private open inner class Inner : java.lang.Object {
+        private constructor Inner()
+    }
+
+    private open class Nested : java.lang.Object {
+        private constructor Nested()
+    }
+
+    private trait SamInterface : java.lang.Object {
+        public abstract fun foo(): kotlin.Unit
+    }
+}
+
+package test.PrivateMembers {
+    private var staticField: kotlin.Int
+    private /*synthesized*/ fun SamInterface(/*0*/ function: () -> kotlin.Unit): test.PrivateMembers.SamInterface
+    private open fun staticMethod(): kotlin.Unit
+
+    package test.PrivateMembers.Nested {
+        private open fun staticMethodInNested(): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java

@@ -0,0 +1,19 @@
+package test;
+
+public class PrivateMembersInHierarchy {
+    public static class Super {
+        private int field = 1;
+        private int field2 = 1;
+
+        private void method() {
+        }
+    }
+
+    public static class Sub extends Super {
+        private int field = 1;
+
+        private void method() {
+        }
+    }
+}
+

compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.txt

@@ -0,0 +1,19 @@
+package test
+
+public open class PrivateMembersInHierarchy : java.lang.Object {
+    public constructor PrivateMembersInHierarchy()
+
+    public open class Sub : test.PrivateMembersInHierarchy.Super {
+        public constructor Sub()
+        private final var field: kotlin.Int
+        invisible_fake final override /*1*/ /*fake_override*/ var field2: kotlin.Int
+        private open fun method(): kotlin.Unit
+    }
+
+    public open class Super : java.lang.Object {
+        public constructor Super()
+        private final var field: kotlin.Int
+        private final var field2: kotlin.Int
+        private open fun method(): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt

@@ -2,9 +2,12 @@ package test
 
 public abstract class ClassDoesNotOverrideMethod : java.util.Date {
     public constructor ClassDoesNotOverrideMethod()
+    invisible_fake final override /*1*/ /*fake_override*/ var cdate: sun.util.calendar.BaseCalendar.Date?
+    invisible_fake final override /*1*/ /*fake_override*/ var fastTime: kotlin.Long
     public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: java.util.Date): kotlin.Int
+    invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarDate(): sun.util.calendar.BaseCalendar.Date?
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDay(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getHours(): kotlin.Int
@@ -12,8 +15,12 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date {
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getMonth(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getSeconds(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun getTime(): kotlin.Long
+    invisible_fake final override /*1*/ /*fake_override*/ fun getTimeImpl(): kotlin.Long
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getTimezoneOffset(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getYear(): kotlin.Int
+    invisible_fake final override /*1*/ /*fake_override*/ fun normalize(): sun.util.calendar.BaseCalendar.Date?
+    invisible_fake final override /*1*/ /*fake_override*/ fun normalize(/*0*/ p0: sun.util.calendar.BaseCalendar.Date?): sun.util.calendar.BaseCalendar.Date?
+    invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream?): kotlin.Unit
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0: kotlin.Int): kotlin.Unit
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0: kotlin.Int): kotlin.Unit
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0: kotlin.Int): kotlin.Unit
@@ -23,4 +30,5 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date {
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0: kotlin.Int): kotlin.Unit
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun toGMTString(): kotlin.String
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun toLocaleString(): kotlin.String
+    invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream?): kotlin.Unit
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt

@@ -17,6 +17,8 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String
     public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<kotlin.String>
+    invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String?
+    invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun remove(/*0*/ index: kotlin.Int): kotlin.String
     public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean

compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt

@@ -0,0 +1,14 @@
+//ALLOW_AST_ACCESS
+
+package test
+
+public class PrivateClassMembers {
+    private val v = 0
+
+    private var r = 0
+        private set
+
+    private fun f() = 0
+
+    internal val internal = 0
+}

compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.txt

@@ -0,0 +1,13 @@
+package test
+
+public final class PrivateClassMembers {
+    /*primary*/ public constructor PrivateClassMembers()
+    internal final val internal: kotlin.Int = 0
+        internal final fun <get-internal>(): kotlin.Int
+    private final var r: kotlin.Int
+        private final fun <get-r>(): kotlin.Int
+        private final fun <set-r>(/*0*/ <set-?>: kotlin.Int): kotlin.Unit
+    private final val v: kotlin.Int = 0
+        private final fun <get-v>(): kotlin.Int
+    private final fun f(): kotlin.Int
+}

compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt

@@ -0,0 +1,4 @@
+package test
+
+public class InheritJavaField(): Super() {
+}

compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.txt

@@ -0,0 +1,15 @@
+package test
+
+public final class InheritJavaField : test.Super {
+    public constructor InheritJavaField()
+    public final override /*1*/ /*fake_override*/ var field: kotlin.Int
+    invisible_fake final override /*1*/ /*fake_override*/ var privateField: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun method(): kotlin.Int
+}
+
+public open class Super : java.lang.Object {
+    public constructor Super()
+    public final var field: kotlin.Int
+    private final var privateField: kotlin.Int
+    public open fun method(): kotlin.Int
+}

compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField/Super.java

@@ -0,0 +1,7 @@
+package test;
+
+public class Super {
+    public int field = 55;
+    private int privateField = 54;
+    public int method() { return 1; }
+}

compiler/testData/psi/BackslashInString.kt

@@ -0,0 +1,3 @@
+fun foo() {
+    "\
+}

compiler/testData/psi/BackslashInString.txt

@@ -0,0 +1,22 @@
+JetFile: BackslashInString.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        PsiErrorElement:Unexpected token in a string template
+          PsiElement(BAD_CHARACTER)('\')
+        PsiErrorElement:Expecting '"'
+          <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/tests/org/jetbrains/jet/codegen/BytecodeTextTestGenerated.java

@@ -122,9 +122,9 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest {
         doTest("compiler/testData/codegen/bytecodeText/kt5016intOrNull.kt");
     }
     
-    @TestMetadata("noVolatileAnnotation.kt")
+    @TestMetadata("noFlagAnnotations.kt")
-    public void testNoVolatileAnnotation() throws Exception {
+    public void testNoFlagAnnotations() throws Exception {
-        doTest("compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt");
+        doTest("compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt");
     }
     
     @TestMetadata("noWrapperForMethodReturningPrimitive.kt")

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java

@@ -48,6 +48,11 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt");
         }
         
+        @TestMetadata("jvmFlags.kt")
+        public void testJvmFlags() throws Exception {
+            doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt");
+        }
+        
         @TestMetadata("kotlinPropertyFromClassObjectAsParameter.kt")
         public void testKotlinPropertyFromClassObjectAsParameter() throws Exception {
             doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt");

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java

@@ -64,6 +64,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java");
         }
         
+        @TestMetadata("PrivateMembers.java")
+        public void testPrivateMembers() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/PrivateMembers.java");
+        }
+        
+        @TestMetadata("PrivateMembersInHierarchy.java")
+        public void testPrivateMembersInHierarchy() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java");
+        }
+        
         @TestMetadata("RawTypeWithUpperBound.java")
         public void testRawTypeWithUpperBound() throws Exception {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java");
@@ -2978,6 +2988,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                 doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt");
             }
             
+            @TestMetadata("PrivateClassMembers.kt")
+            public void testPrivateClassMembers() throws Exception {
+                doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt");
+            }
+            
             @TestMetadata("PrivateTopLevelFun.kt")
             public void testPrivateTopLevelFun() throws Exception {
                 doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt");
@@ -3167,6 +3182,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), false);
         }
         
+        @TestMetadata("InheritJavaField.kt")
+        public void testInheritJavaField() throws Exception {
+            doTestKotlinAgainstCompiledJavaWithKotlin("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt");
+        }
+        
         @TestMetadata("InheritParameterName.kt")
         public void testInheritParameterName() throws Exception {
             doTestKotlinAgainstCompiledJavaWithKotlin("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritParameterName.kt");

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveRecursiveComparingTestGenerated.java

@@ -1456,6 +1456,11 @@ public class LazyResolveRecursiveComparingTestGenerated extends AbstractLazyReso
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt");
             }
             
+            @TestMetadata("PrivateClassMembers.kt")
+            public void testPrivateClassMembers() throws Exception {
+                doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt");
+            }
+            
             @TestMetadata("PrivateTopLevelFun.kt")
             public void testPrivateTopLevelFun() throws Exception {
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt");

compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java

@@ -84,6 +84,11 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
             doParsingTest("compiler/testData/psi/BabySteps_ERR.kt");
         }
         
+        @TestMetadata("BackslashInString.kt")
+        public void testBackslashInString() throws Exception {
+            doParsingTest("compiler/testData/psi/BackslashInString.kt");
+        }
+        
         @TestMetadata("BlockCommentAtBeginningOfFile1.kt")
         public void testBlockCommentAtBeginningOfFile1() throws Exception {
             doParsingTest("compiler/testData/psi/BlockCommentAtBeginningOfFile1.kt");

core/builtins/src/kotlin/Progressions.kt

@@ -29,10 +29,14 @@ public class ByteProgression(
 
     override fun iterator(): ByteIterator = ByteProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is ByteProgression && start == other.start && end == other.end && increment == other.increment
 
-    override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment
+    override fun equals(other: Any?): Boolean =
+        other is ByteProgression && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end && increment == other.increment)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -48,10 +52,14 @@ public class CharProgression(
 
     override fun iterator(): CharIterator = CharProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is CharProgression && start == other.start && end == other.end && increment == other.increment
 
-    override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment
+    override fun equals(other: Any?): Boolean =
+        other is CharProgression && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end && increment == other.increment)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -67,10 +75,14 @@ public class ShortProgression(
 
     override fun iterator(): ShortIterator = ShortProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is ShortProgression && start == other.start && end == other.end && increment == other.increment
 
-    override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment
+    override fun equals(other: Any?): Boolean =
+        other is ShortProgression && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end && increment == other.increment)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -86,10 +98,14 @@ public class IntProgression(
 
     override fun iterator(): IntIterator = IntProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is IntProgression && start == other.start && end == other.end && increment == other.increment
 
-    override fun hashCode(): Int = 31 * (31 * start + end) + increment
+    override fun equals(other: Any?): Boolean =
+        other is IntProgression && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end && increment == other.increment)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * start + end) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -105,10 +121,14 @@ public class LongProgression(
 
     override fun iterator(): LongIterator = LongProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is LongProgression && start == other.start && end == other.end && increment == other.increment
 
-    override fun hashCode(): Int = (31 * (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))) + (increment xor (increment ushr 32))).toInt()
+    override fun equals(other: Any?): Boolean =
+        other is LongProgression && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end && increment == other.increment)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))) + (increment xor (increment ushr 32))).toInt()
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -125,10 +145,14 @@ public class FloatProgression(
 
     override fun iterator(): FloatIterator = FloatProgressionIterator(start, end, increment)
 
-    override fun equals(other: Any?): Boolean =
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
-        other is FloatProgression && java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0 && java.lang.Float.compare(increment, other.increment) == 0
 
-    override fun hashCode(): Int = 31 * (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)) + java.lang.Float.floatToIntBits(increment)
+    override fun equals(other: Any?): Boolean =
+        other is FloatProgression && (isEmpty() && other.isEmpty() ||
+        java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0 && java.lang.Float.compare(increment, other.increment) == 0)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)) + java.lang.Float.floatToIntBits(increment))
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -145,10 +169,14 @@ public class DoubleProgression(
 
     override fun iterator(): DoubleIterator = DoubleProgressionIterator(start, end, increment)
 
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
+
     override fun equals(other: Any?): Boolean =
-        other is DoubleProgression && java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0 && java.lang.Double.compare(increment, other.increment) == 0
+        other is DoubleProgression && (isEmpty() && other.isEmpty() ||
+        java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0 && java.lang.Double.compare(increment, other.increment) == 0)
 
     override fun hashCode(): Int {
+        if (isEmpty()) return -1
         var temp = java.lang.Double.doubleToLongBits(start)
         var result = (temp xor (temp ushr 32))
         temp = java.lang.Double.doubleToLongBits(end)

core/builtins/src/kotlin/Range.kt

@@ -23,5 +23,7 @@ public trait Range<T : Comparable<T>> {
 
     public fun contains(item: T): Boolean
 
+    public fun isEmpty(): Boolean = start > end
+
     override fun toString(): String = "$start..$end"
 }

core/builtins/src/kotlin/Ranges.kt

@@ -26,10 +26,14 @@ public class ByteRange(public override val start: Byte, public override val end:
 
     override fun iterator(): ByteIterator = ByteProgressionIterator(start, end, 1)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is ByteRange && start == other.start && end == other.end
 
-    override fun hashCode(): Int = 31 * start.toInt() + end
+    override fun equals(other: Any?): Boolean =
+        other is ByteRange && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * start.toInt() + end)
 
     class object {
         public val EMPTY: ByteRange = ByteRange(1, 0)
@@ -44,10 +48,14 @@ public class CharRange(public override val start: Char, public override val end:
 
     override fun iterator(): CharIterator = CharProgressionIterator(start, end, 1)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is CharRange && start == other.start && end == other.end
 
-    override fun hashCode(): Int = 31 * start.toInt() + end
+    override fun equals(other: Any?): Boolean =
+        other is CharRange && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * start.toInt() + end)
 
     class object {
         public val EMPTY: CharRange = CharRange(1.toChar(), 0.toChar())
@@ -62,10 +70,14 @@ public class ShortRange(public override val start: Short, public override val en
 
     override fun iterator(): ShortIterator = ShortProgressionIterator(start, end, 1)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is ShortRange && start == other.start && end == other.end
 
-    override fun hashCode(): Int = 31 * start.toInt() + end
+    override fun equals(other: Any?): Boolean =
+        other is ShortRange && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * start.toInt() + end)
 
     class object {
         public val EMPTY: ShortRange = ShortRange(1, 0)
@@ -80,10 +92,14 @@ public class IntRange(public override val start: Int, public override val end: I
 
     override fun iterator(): IntIterator = IntProgressionIterator(start, end, 1)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is IntRange && start == other.start && end == other.end
 
-    override fun hashCode(): Int = 31 * start + end
+    override fun equals(other: Any?): Boolean =
+        other is IntRange && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * start + end)
 
     class object {
         public val EMPTY: IntRange = IntRange(1, 0)
@@ -98,10 +114,14 @@ public class LongRange(public override val start: Long, public override val end:
 
     override fun iterator(): LongIterator = LongProgressionIterator(start, end, 1)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is LongRange && start == other.start && end == other.end
 
-    override fun hashCode(): Int = (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))).toInt()
+    override fun equals(other: Any?): Boolean =
+        other is LongRange && (isEmpty() && other.isEmpty() ||
+        start == other.start && end == other.end)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))).toInt()
 
     class object {
         public val EMPTY: LongRange = LongRange(1, 0)
@@ -116,10 +136,14 @@ public class FloatRange(public override val start: Float, public override val en
 
     override fun iterator(): FloatIterator = FloatProgressionIterator(start, end, 1.0f)
 
-    override fun equals(other: Any?): Boolean =
+    override fun isEmpty(): Boolean = start > end
-        other is FloatRange && java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0
 
-    override fun hashCode(): Int = 31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)
+    override fun equals(other: Any?): Boolean =
+        other is FloatRange && (isEmpty() && other.isEmpty() ||
+        java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0)
+
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end))
 
     class object {
         public val EMPTY: FloatRange = FloatRange(1.0f, 0.0f)
@@ -134,10 +158,14 @@ public class DoubleRange(public override val start: Double, public override val
 
     override fun iterator(): DoubleIterator = DoubleProgressionIterator(start, end, 1.0)
 
+    override fun isEmpty(): Boolean = start > end
+
     override fun equals(other: Any?): Boolean =
-        other is DoubleRange && java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0
+        other is DoubleRange && (isEmpty() && other.isEmpty() ||
+        java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0)
 
     override fun hashCode(): Int {
+        if (isEmpty()) return -1
         var temp = java.lang.Double.doubleToLongBits(start)
         val result = (temp xor (temp ushr 32))
         temp = java.lang.Double.doubleToLongBits(end)

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/MemberIndex.kt

@@ -41,13 +41,7 @@ object EMPTY_MEMBER_INDEX : MemberIndex {
     override fun getAllFieldNames() = listOf<Name>()
 }
 
-open class ClassMemberIndex(val jClass: JavaClass, filter: (JavaMember) -> Boolean) : MemberIndex {
+open class ClassMemberIndex(val jClass: JavaClass, val memberFilter: (JavaMember) -> Boolean) : MemberIndex {
-    private val memberFilter = {
-        (m: JavaMember) ->
-        filter(m) &&
-        m.getVisibility() != Visibilities.PRIVATE
-    }
-
     private val methodFilter = {
         (m: JavaMethod) ->
         memberFilter(m) &&

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

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf;
 import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl;
@@ -46,10 +46,10 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
 
-public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer implements AnnotationDeserializer {
+public class AnnotationDescriptorLoader extends BaseDescriptorLoader implements AnnotationLoader {
     @Inject
     @Override
     public void setStorage(@NotNull DescriptorDeserializersStorage storage) {

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

@@ -31,14 +31,14 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
 import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.naiveKotlinFqName;
 
-public abstract class BaseDescriptorDeserializer {
+public abstract class BaseDescriptorLoader {
     protected DependencyClassByQualifiedNameResolver classResolver;
     protected KotlinClassFinder kotlinClassFinder;
     protected ErrorReporter errorReporter;

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

@@ -20,7 +20,7 @@ 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.descriptors.serialization.descriptors.ConstantLoader;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
@@ -28,10 +28,10 @@ import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
 import javax.inject.Inject;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
 
-public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer {
+public class ConstantDescriptorLoader extends BaseDescriptorLoader implements ConstantLoader {
     @Inject
     @Override
     public void setStorage(@NotNull DescriptorDeserializersStorage storage) {

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

@@ -1,52 +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.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;
-
-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

@@ -108,7 +108,7 @@ public class DescriptorDeserializersStorage {
                         result = new ArrayList<AnnotationDescriptor>();
                         memberAnnotations.put(paramSignature, result);
                     }
-                    return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver);
+                    return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver);
                 }
             }
 
@@ -123,7 +123,7 @@ public class DescriptorDeserializersStorage {
                 @Nullable
                 @Override
                 public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitAnnotation(@NotNull JvmClassName className) {
-                    return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver);
+                    return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver);
                 }
 
                 @Override

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

@@ -0,0 +1,29 @@
+/*
+ * 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.jet.descriptors.serialization.context.DeserializationGlobalContext
+import org.jetbrains.jet.storage.StorageManager
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider
+
+public class DeserializationGlobalContextForJava(
+        storageManager: StorageManager,
+        descriptorFinder: JavaDescriptorFinder,
+        annotationLoader: AnnotationDescriptorLoader,
+        constantLoader: ConstantDescriptorLoader,
+        packageFragmentProvider: LazyJavaPackageFragmentProvider
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, constantLoader, packageFragmentProvider)

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

@@ -19,68 +19,28 @@ package org.jetbrains.jet.lang.resolve.kotlin;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.ClassData;
-import org.jetbrains.jet.descriptors.serialization.ClassId;
-import org.jetbrains.jet.descriptors.serialization.DescriptorFinder;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.storage.StorageManager;
 
 import javax.inject.Inject;
-import java.util.Collection;
 
-import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.CLASS;
 import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.PACKAGE_FACADE;
 
 public final class DeserializedDescriptorResolver {
-    private DescriptorDeserializers deserializers;
+    private DeserializationGlobalContextForJava context;
-
-    private StorageManager storageManager;
-
-    private JavaPackageFragmentProvider javaPackageFragmentProvider;
-
-    private JavaDescriptorResolver javaDescriptorResolver;
 
     private ErrorReporter errorReporter;
 
-    @NotNull
-    private final DescriptorFinder javaDescriptorFinder = new DescriptorFinder() {
-        @Nullable
-        @Override
-        public ClassDescriptor findClass(@NotNull ClassId classId) {
-            return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()));
-        }
-
-        @NotNull
-        @Override
-        public Collection<Name> getClassNames(@NotNull FqName packageName) {
-            return javaPackageFragmentProvider.getClassNamesInPackage(packageName);
-        }
-    };
-
     @Inject
-    public void setDeserializers(DescriptorDeserializers deserializers) {
+    public void setContext(DeserializationGlobalContextForJava context) {
-        this.deserializers = deserializers;
+        this.context = context;
-    }
-
-    @Inject
-    public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) {
-        this.javaPackageFragmentProvider = javaPackageFragmentProvider;
-    }
-
-    @Inject
-    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
     }
 
     @Inject
@@ -88,18 +48,12 @@ public final class DeserializedDescriptorResolver {
         this.errorReporter = errorReporter;
     }
 
-    @Inject
-    public void setStorageManager(StorageManager storageManager) {
-        this.storageManager = storageManager;
-    }
-
     @Nullable
     public ClassDescriptor resolveClass(@NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, CLASS);
         if (data != null) {
             ClassData classData = JavaProtoBufUtil.readClassDataFrom(data);
-            return new DeserializedClassDescriptor(storageManager, deserializers, javaDescriptorFinder,
+            return new DeserializedClassDescriptor(context, classData);
-                                                   javaPackageFragmentProvider, classData.getNameResolver(), classData.getClassProto());
         }
         return null;
     }
@@ -108,8 +62,7 @@ public final class DeserializedDescriptorResolver {
     public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, PACKAGE_FACADE);
         if (data != null) {
-            return new DeserializedPackageMemberScope(storageManager, descriptor, deserializers,
+            return new DeserializedPackageMemberScope(descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context);
-                                                      javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data));
         }
         return null;
     }

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

@@ -0,0 +1,41 @@
+/*
+ * 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.Nullable
+import org.jetbrains.jet.descriptors.serialization.ClassId
+import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName
+
+public class JavaDescriptorFinder(
+        private val javaDescriptorResolver: DependencyClassByQualifiedNameResolver,
+        private val javaPackageFragmentProvider: JavaPackageFragmentProvider
+) : DescriptorFinder {
+
+    override fun findClass(classId: ClassId): ClassDescriptor? {
+        return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()))
+    }
+
+    override fun getClassNames(packageName: FqName): Collection<Name> {
+        return javaPackageFragmentProvider.getClassNamesInPackage(packageName)
+    }
+}

core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java

@@ -346,9 +346,10 @@ public class OverridingUtil {
             @NotNull DescriptorSink sink
     ) {
         Collection<CallableMemberDescriptor> visibleOverridables = filterVisibleFakeOverrides(current, overridables);
-        Modality modality = getMinimalModality(visibleOverridables);
         boolean allInvisible = visibleOverridables.isEmpty();
         Collection<CallableMemberDescriptor> effectiveOverridden = allInvisible ? overridables : visibleOverridables;
+
+        Modality modality = getMinimalModality(effectiveOverridden);
         Visibility visibility = allInvisible ? Visibilities.INVISIBLE_FAKE : Visibilities.INHERITED;
         CallableMemberDescriptor mostSpecific = selectMostSpecificMemberFromSuper(effectiveOverridden);
         CallableMemberDescriptor fakeOverride =

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java

@@ -20,8 +20,8 @@ import kotlin.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
-import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
+import org.jetbrains.jet.descriptors.serialization.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl;
@@ -51,9 +51,13 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
 
         packageFragmentProvider = new BuiltinsPackageFragmentProvider();
 
-        // TODO: support annotations
+        DeserializationContext context = new DeserializationContext(
-        members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED,
+                storageManager, new BuiltInsDescriptorFinder(storageManager),
-                                                     new BuiltInsDescriptorFinder(storageManager), new PackageData(nameResolver, loadPackage()));
+                // TODO: support annotations
+                AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider,
+                nameResolver
+        );
+        members = new DeserializedPackageMemberScope(this, loadPackage(), context);
     }
 
     @NotNull
@@ -118,7 +122,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
 
         public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) {
             // TODO: support annotations
-            super(storageManager, Deserializers.UNSUPPORTED, packageFragmentProvider);
+            super(storageManager, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider);
 
             classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override

core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java

@@ -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.context.DeserializationGlobalContext;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
+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 StorageManager storageManager,
-            @NotNull Deserializers deserializers,
+            @NotNull AnnotationLoader annotationLoader,
-            @NotNull final PackageFragmentProvider packageFragmentProvider
+            @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 classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData);
-                    return null;
-                }
-
-                AbstractDescriptorFinder _this = AbstractDescriptorFinder.this;
-                return new DeserializedClassDescriptor(storageManager, _this.deserializers, _this, packageFragmentProvider,
-                                                classData.getNameResolver(), classData.getClassProto());
             }
         });
     }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.java

@@ -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.SerializationPackage.*;
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
 
-public class DescriptorDeserializer {
+public class MemberDeserializer {
 
-    @NotNull
+    private final DeserializationContextWithTypes context;
-    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);
-    }
 
-    @NotNull
+    public MemberDeserializer(@NotNull DeserializationContextWithTypes context) {
-    public static DescriptorDeserializer create(
+        this.context = context;
-            @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);
     }
 
     @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()),
+                context.getNameResolver().getName(proto.getName()),
-                memberKind(Flags.MEMBER_KIND.get(flags)),
+                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(),
+                DeserializationContextWithTypes setterLocal = local.childContext(setter, Collections.<TypeParameter>emptyList(),
-                                                                                   Collections.<TypeParameterDescriptor>emptyList());
+                                                                                 Collections.<TypeParameterDescriptor>emptyList());
-                List<ValueParameterDescriptor> valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
+                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(
+                            return context.getConstantLoader().loadPropertyConstant(
-                                                            (ClassOrPackageFragmentDescriptor) containingDeclaration,
+                                    (ClassOrPackageFragmentDescriptor) containingDeclaration, proto,
-                                                            proto, nameResolver,
+                                    context.getNameResolver(), AnnotatedCallableKind.PROPERTY);
-                                                            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,
+                context.getContainingDeclaration(), proto, context.getAnnotationLoader(), context.getNameResolver()
-                deserializers,
-                nameResolver
         );
         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.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION),
-                local.typeDeserializer.type(proto.getReturnType()),
+                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)
+        return Flags.HAS_ANNOTATIONS.get(flags) ? annotationLoader.loadCallableAnnotations(
-               ? annotationDeserializer
+                (ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) : Annotations.EMPTY;
-                       .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);
     }
 
     @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,
+                    context.getContainingDeclaration(),
-                    nameResolver.getName(proto.getName()),
+                    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()),
+                    context.getNameResolver().getName(proto.getName()),
-                    typeDeserializer.type(proto.getType()),
+                    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())
+        return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) ? context.getAnnotationLoader()
-               ? deserializers.getAnnotationDeserializer().loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter)
+                       .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
                : Annotations.EMPTY;
     }
 }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java

@@ -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 DeserializationContext context,
-            @NotNull TypeDeserializer parent,
-            @NotNull String debugName,
-            @NotNull TypeParameterResolver typeParameterResolver
-    ) {
-        this(storageManager, parent, parent.nameResolver, parent.descriptorFinder, debugName, typeParameterResolver);
-    }
-
-    public TypeDeserializer(
-            @NotNull StorageManager storageManager,
             @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>() {
+        this.classDescriptors = context.getStorageManager().createMemoizedFunctionWithNullableValues(
-            @Override
+                new Function1<Integer, ClassDescriptor>() {
-            public ClassDescriptor invoke(Integer fqNameIndex) {
+                    @Override
-                return computeClassDescriptor(fqNameIndex);
+                    public ClassDescriptor invoke(Integer fqNameIndex) {
-            }
+                        return computeClassDescriptor(fqNameIndex);
-        });
+                    }
-    }
+                });
-
-    /* package */ DescriptorFinder getDescriptorFinder() {
-        return descriptorFinder;
     }
 
     @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);
+        ClassId classId = context.getNameResolver().getClassId(fqNameIndex);
-        return descriptorFinder.findClass(classId);
+        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(
+        return new TypeProjectionImpl(variance(proto.getProjection()), type(proto.getType()));
-                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);
     }
 
     @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

@@ -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

@@ -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/AnnotationLoader.java

@@ -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 AnnotationLoader {
-
+    AnnotationLoader UNSUPPORTED = new AnnotationLoader() {
-public interface AnnotationDeserializer {
-    AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
         @NotNull
         @Override
         public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java

@@ -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 ConstantLoader {
-
+    ConstantLoader UNSUPPORTED = new ConstantLoader() {
-public interface ConstantDeserializer {
-    ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() {
         @Nullable
         @Override
         public CompileTimeConstant<?> loadPropertyConstant(

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -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 DeserializationContextWithTypes context;
-    private final PackageFragmentProvider packageFragmentProvider;
 
-    public DeserializedClassDescriptor(
+    public DeserializedClassDescriptor(@NotNull DeserializationGlobalContext globalContext, @NotNull ClassData classData) {
-            @NotNull StorageManager storageManager,
+        this(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto());
-            @NotNull Deserializers deserializers,
+    }
-            @NotNull DescriptorFinder descriptorFinder,
+
-            @NotNull PackageFragmentProvider packageFragmentProvider,
+    public DeserializedClassDescriptor(@NotNull DeserializationContext outerContext, @NotNull ProtoBuf.Class classProto) {
-            @NotNull NameResolver nameResolver,
+        super(outerContext.getStorageManager(),
-            @NotNull ProtoBuf.Class classProto
+              outerContext.getNameResolver().getClassId(classProto.getFqName()).getRelativeClassName().shortName());
-    ) {
-        super(storageManager, nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName());
         this.classProto = classProto;
-        this.classId = nameResolver.getClassId(classProto.getFqName());
+        this.classId = outerContext.getNameResolver().getClassId(classProto.getFqName());
-        this.storageManager = storageManager;
-        this.packageFragmentProvider = packageFragmentProvider;
-        this.descriptorFinder = descriptorFinder;
 
-        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.context = outerContext.withTypes(this).childContext(this, classProto.getTypeParameterList(), typeParameters);
-        this.typeDeserializer = deserializer.getTypeDeserializer();
 
-        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.modality = modality(Flags.MODALITY.get(flags));
-        this.visibility = DescriptorDeserializer.visibility(Flags.VISIBILITY.get(flags));
+        this.visibility = visibility(Flags.VISIBILITY.get(flags));
-        this.kind = DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(flags));
+        this.kind = classKind(Flags.CLASS_KIND.get(flags));
         this.isInner = Flags.INNER.get(flags);
 
-        this.deserializers = deserializers;
+        this.annotations = context.getStorageManager().createLazyValue(new Function0<Annotations>() {
-        this.annotations = storageManager.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,
+            return new DeserializedClassDescriptor(context, classObjectProto.getData());
-                                                   deserializer.getNameResolver(), 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) {
+        public DeserializedClassMemberScope() {
-            super(storageManager, classDescriptor, classDescriptor.deserializer, classDescriptor.classProto.getMemberList());
+            super(context, DeserializedClassDescriptor.this.classProto.getMemberList());
-            this.classDescriptor = classDescriptor;
+            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

@@ -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 DeserializationContextWithTypes context,
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull DescriptorDeserializer deserializer,
             @NotNull final Collection<ProtoBuf.Callable> membersList
     ) {
-        this.containingDeclaration = containingDeclaration;
+        this.context = context;
-        this.deserializer = deserializer;
 
+        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>>() {
+        this.properties = storageManager.createMemoizedFunction(
-            @Override
+                new Function1<Name, Collection<VariableDescriptor>>() {
-            public Collection<VariableDescriptor> invoke(Name name) {
+                    @Override
-                return computeProperties(name);
+                    public Collection<VariableDescriptor> invoke(Name name) {
-            }
+                        return computeProperties(name);
-        });
+                    }
-        this.allDescriptors = storageManager.createLazyValue(new Function0<Collection<DeclarationDescriptor>>() {
+                }
-            @Override
+        );
-            public Collection<DeclarationDescriptor> invoke() {
+        this.allDescriptors = storageManager.createLazyValue(
-                return computeAllDescriptors();
+                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

@@ -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 ProtoBuf.Package proto,
-            @NotNull DescriptorFinder descriptorFinder,
+            @NotNull DeserializationContext context
-            @NotNull PackageData packageData
     ) {
-        super(storageManager, packageDescriptor,
+        super(context.withTypes(packageDescriptor), proto.getMemberList());
-              DescriptorDeserializer.create(storageManager, packageDescriptor, packageData.getNameResolver(), descriptorFinder, deserializers),
+        this.context = context;
-              packageData.getPackageProto().getMemberList());
-        this.descriptorFinder = descriptorFinder;
         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

@@ -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.*;
-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.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(),
+        Annotations annotations = MemberDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
-                                                                        Deserializers.AnnotatedCallableKind.FUNCTION,
+                                                                    AnnotatedCallableKind.FUNCTION,
-                                                                        deserializers.getAnnotationDeserializer(),
+                                                                    annotationLoader,
-                                                                        nameResolver);
+                                                                    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

@@ -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

@@ -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
+}

generators/src/org/jetbrains/jet/generators/builtins/progressions.kt

@@ -45,11 +45,16 @@ class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) {
             val constructor = checkNaN + checkZero
 
             val hashCode = when (kind) {
-                BYTE, CHAR, SHORT -> "= 31 * (31 * start.toInt() + end) + increment"
+                BYTE, CHAR, SHORT -> "=\n" +
-                INT -> "= 31 * (31 * start + end) + increment"
+                "        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)"
-                LONG -> "= (31 * (31 * ${hashLong("start")} + ${hashLong("end")}) + ${hashLong("increment")}).toInt()"
+                INT -> "=\n" +
-                FLOAT -> "= 31 * (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}) + ${floatToIntBits("increment")}"
+                "        if (isEmpty()) -1 else (31 * (31 * start + end) + increment)"
+                LONG -> "=\n" +
+                "        if (isEmpty()) -1 else (31 * (31 * ${hashLong("start")} + ${hashLong("end")}) + ${hashLong("increment")}).toInt()"
+                FLOAT -> "=\n" +
+                "        if (isEmpty()) -1 else (31 * (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}) + ${floatToIntBits("increment")})"
                 DOUBLE -> "{\n" +
+                "        if (isEmpty()) return -1\n" +
                 "        var temp = ${doubleToLongBits("start")}\n" +
                 "        var result = ${hashLong("temp")}\n" +
                 "        temp = ${doubleToLongBits("end")}\n" +
@@ -71,8 +76,11 @@ class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) {
 
     override fun iterator(): ${t}Iterator = ${t}ProgressionIterator(start, end, increment)
 
+    public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end
+
     override fun equals(other: Any?): Boolean =
-        other is $progression && ${compare("start")} && ${compare("end")} && ${compare("increment")}
+        other is $progression && (isEmpty() && other.isEmpty() ||
+        ${compare("start")} && ${compare("end")} && ${compare("increment")})
 
     override fun hashCode(): Int $hashCode
 

generators/src/org/jetbrains/jet/generators/builtins/ranges.kt

@@ -45,11 +45,16 @@ class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) {
             fun compare(v: String) = areEqualNumbers(kind, v)
 
             val hashCode = when (kind) {
-                BYTE, CHAR, SHORT -> "= 31 * start.toInt() + end"
+                BYTE, CHAR, SHORT -> "=\n" +
-                INT -> "= 31 * start + end"
+                "        if (isEmpty()) -1 else (31 * start.toInt() + end)"
-                LONG -> "= (31 * ${hashLong("start")} + ${hashLong("end")}).toInt()"
+                INT -> "=\n" +
-                FLOAT -> "= 31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}"
+                "        if (isEmpty()) -1 else (31 * start + end)"
+                LONG -> "=\n" +
+                "        if (isEmpty()) -1 else (31 * ${hashLong("start")} + ${hashLong("end")}).toInt()"
+                FLOAT -> "=\n" +
+                "        if (isEmpty()) -1 else (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")})"
                 DOUBLE -> "{\n" +
+                "        if (isEmpty()) return -1\n" +
                 "        var temp = ${doubleToLongBits("start")}\n" +
                 "        val result = ${hashLong("temp")}\n" +
                 "        temp = ${doubleToLongBits("end")}\n" +
@@ -66,8 +71,11 @@ class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) {
 
     override fun iterator(): ${t}Iterator = ${t}ProgressionIterator(start, end, $increment)
 
+    override fun isEmpty(): Boolean = start > end
+
     override fun equals(other: Any?): Boolean =
-        other is $range && ${compare("start")} && ${compare("end")}
+        other is $range && (isEmpty() && other.isEmpty() ||
+        ${compare("start")} && ${compare("end")})
 
     override fun hashCode(): Int $hashCode
 

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils
 import org.jetbrains.jet.lang.resolve.calls.CallResolver
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava
 
 // NOTE: After making changes, you need to re-generate the injectors.
 //       To do that, you can run main in this file.
@@ -98,7 +98,7 @@ private fun generatorForTopDownAnalyzerForJvm() =
             commonForTopDownAnalyzer()
 
             publicField(javaClass<JavaDescriptorResolver>())
-            publicField(javaClass<DescriptorDeserializers>())
+            publicField(javaClass<DeserializationGlobalContextForJava>())
 
             fields(
                     javaClass<JavaClassFinderImpl>(),

generators/src/org/jetbrains/jet/generators/mockJDK/GenerateMockJdk.java

@@ -270,6 +270,7 @@ public class GenerateMockJdk {
             "javax/swing/SwingConstants.class",
             "javax/swing/SwingUtilities.class",
             "javax/swing/table/TableModel.class",
+            "sun/util/calendar/BaseCalendar.class",
             "META-INF/",
             "META-INF/MANIFEST.MF",
     };

idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java

@@ -90,7 +90,7 @@ public class JetFromJavaDescriptorHelper {
     public static ClassKind getCompiledClassKind(@NotNull PsiClass psiClass) {
         ClassData classData = getClassData(psiClass);
         if (classData == null) return null;
-        return DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags()));
+        return SerializationPackage.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags()));
     }
 
 

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

@@ -33,17 +33,17 @@ import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter
 import org.jetbrains.jet.lang.types.error.MissingDependencyErrorClassDescriptor
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import com.intellij.openapi.diagnostic.Logger
 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
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext
 
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -67,11 +67,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
             return Collections.emptyList()
         }
         val membersScope = DeserializedPackageMemberScope(
-                storageManager,
                 createDummyPackageFragment(packageFqName),
-                deserializers,
+                JavaProtoBufUtil.readPackageDataFrom(annotationData),
-                descriptorFinder,
+                deserializationContext
-                JavaProtoBufUtil.readPackageDataFrom(annotationData)
         )
         return membersScope.getAllDescriptors()
     }
@@ -108,32 +106,26 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         deserializerStorage.setErrorReporter(LOGGING_REPORTER)
     }
 
-    private val annotationDeserializer = AnnotationDescriptorDeserializer();
+    private val annotationLoader = AnnotationDescriptorLoader();
     {
-        annotationDeserializer.setClassResolver {
+        annotationLoader.setClassResolver {
             fqName ->
             classes(fqName.toClassId())
         }
-        annotationDeserializer.setKotlinClassFinder(localClassFinder)
+        annotationLoader.setKotlinClassFinder(localClassFinder)
-        annotationDeserializer.setErrorReporter(LOGGING_REPORTER)
+        annotationLoader.setErrorReporter(LOGGING_REPORTER)
-        annotationDeserializer.setStorage(deserializerStorage)
+        annotationLoader.setStorage(deserializerStorage)
     }
 
-    private val constantDeserializer = ConstantDescriptorDeserializer();
+    private val constantLoader = ConstantDescriptorLoader();
     {
-        constantDeserializer.setClassResolver {
+        constantLoader.setClassResolver {
             fqName ->
             classes(fqName.toClassId())
         }
-        constantDeserializer.setKotlinClassFinder(localClassFinder)
+        constantLoader.setKotlinClassFinder(localClassFinder)
-        constantDeserializer.setErrorReporter(LOGGING_REPORTER)
+        constantLoader.setErrorReporter(LOGGING_REPORTER)
-        constantDeserializer.setStorage(deserializerStorage)
+        constantLoader.setStorage(deserializerStorage)
-    }
-
-    private val deserializers = DescriptorDeserializers();
-    {
-        deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer)
-        deserializers.setConstantDescriptorDeserializer(constantDeserializer)
     }
 
     private val descriptorFinder = object : DescriptorFinder {
@@ -156,6 +148,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         }
     }
 
+    val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
+                                                              constantLoader, packageFragmentProvider)
+
     private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor {
         return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName)
     }
@@ -182,8 +177,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
             LOG.error("Annotation data missing for ${kotlinClass.getClassName()}")
         }
         val classData = JavaProtoBufUtil.readClassDataFrom(data!!)
-        return DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider,
+        return DeserializedClassDescriptor(deserializationContext, classData)
-                                           classData.getNameResolver(), classData.getClassProto())
     }
 
     // we need a "magic" way to obtain ClassId from FqName

idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java

@@ -1456,6 +1456,11 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt");
             }
             
+            @TestMetadata("PrivateClassMembers.kt")
+            public void testPrivateClassMembers() throws Exception {
+                doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt");
+            }
+            
             @TestMetadata("PrivateTopLevelFun.kt")
             public void testPrivateTopLevelFun() throws Exception {
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt");

jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.jps.build;
 
-import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.containers.ContainerUtil;
@@ -101,9 +100,7 @@ public class KotlinBuilderModuleScriptGenerator {
 
         if (noSources) return null;
 
-        String scriptFilename = context.getProjectDescriptor().dataManager.getDataPaths().getDataStorageRoot().getName()
+        File scriptFile = File.createTempFile("kjps", StringUtil.sanitizeJavaIdentifier(chunk.getName()) + ".script.xml");
-                   + "#" + StringUtil.sanitizeJavaIdentifier(chunk.getName());
-        File scriptFile = new File(PathManager.getTempPath() + File.separator + scriptFilename + ".script." + FACTORY.getFileExtension());
 
         writeScriptToFile(context, builder.asText(), scriptFile);
 

js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java

@@ -190,4 +190,8 @@ public final class MiscTest extends AbstractExpressionTest {
     public void testStringInterpolationEvaluationOrder() throws Exception {
         fooBoxTest();
     }
+
+    public void testKt5058() throws Exception {
+        checkFooBoxIsTrue("KT-5058.kt");
+    }
 }

js/js.tests/test/org/jetbrains/k2js/test/semantics/PatternMatchingTest.java

@@ -89,4 +89,20 @@ public final class PatternMatchingTest extends SingleFileTranslationTest {
     public void testIfInWhen() throws Exception {
         checkFooBoxIsOk();
     }
+
+    public void testForWithOneStmWhen() throws Exception {
+        fooBoxTest();
+    }
+
+    public void testWhileWithOneStmWhen() throws Exception {
+        fooBoxTest();
+    }
+
+    public void testDoWhileWithOneStmWhen() throws Exception {
+        fooBoxTest();
+    }
+
+    public void testIfWithOneStmWhen() throws Exception {
+        fooBoxTest();
+    }
 }

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -49,10 +49,10 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
-import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -93,10 +93,10 @@ public class InjectorForTopDownAnalyzerForJs {
     private final DeclarationResolver declarationResolver;
     private final ImportsResolver importsResolver;
     private final JetImportsFactory jetImportsFactory;
-    private final ScriptHeaderResolver scriptHeaderResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final TypeHierarchyResolver typeHierarchyResolver;
+    private final ScriptHeaderResolver scriptHeaderResolver;
     
     public InjectorForTopDownAnalyzerForJs(
         @NotNull Project project,
@@ -137,10 +137,10 @@ public class InjectorForTopDownAnalyzerForJs {
         this.declarationResolver = new DeclarationResolver();
         this.importsResolver = new ImportsResolver();
         this.jetImportsFactory = new JetImportsFactory();
-        this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
+        this.scriptHeaderResolver = new ScriptHeaderResolver();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -232,7 +232,6 @@ public class InjectorForTopDownAnalyzerForJs {
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
-        declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);
         declarationResolver.setTrace(bindingTrace);
 
         importsResolver.setImportsFactory(jetImportsFactory);
@@ -242,9 +241,6 @@ public class InjectorForTopDownAnalyzerForJs {
 
         jetImportsFactory.setProject(project);
 
-        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        scriptHeaderResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);
@@ -255,6 +251,9 @@ public class InjectorForTopDownAnalyzerForJs {
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
+        scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        scriptHeaderResolver.setTrace(bindingTrace);
+
     }
     
     @PreDestroy

js/js.translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java

@@ -40,8 +40,9 @@ public final class WhenTranslator extends AbstractTranslator {
         WhenTranslator translator = new WhenTranslator(expression, context);
 
         if (BindingUtils.isStatement(context.bindingContext(), expression)) {
-            translator.translateAsStatement(context.dynamicContext().jsBlock().getStatements());
+            JsBlock jsBlock = new JsBlock();
-            return null;
+            translator.translateAsStatement(jsBlock.getStatements());
+            return jsBlock;
         }
 
         return translator.translateAsExpression();

js/js.translator/testData/expression/misc/cases/KT-5058.kt

@@ -0,0 +1,25 @@
+package foo
+
+fun test():Any {
+    val a: Any = "OK"
+    val f: Any =
+            if (true) {
+                when {
+                    false -> "1"
+                    ((a as? String)?.size ?: 0 > 0) -> a
+                    else -> "2"
+                }
+            }
+            else {
+                "3"
+
+            }
+
+    return f
+}
+
+fun box(): Boolean {
+    var result = test()
+    return result == "OK";
+}
+

js/js.translator/testData/kotlin_lib.js

@@ -543,6 +543,9 @@
             },
             iterator: function () {
                 return new Kotlin.RangeIterator(this.start, this.end, this.increment);
+            },
+            isEmpty: function () {
+                return this.start > this.end;
             }
     });
 
@@ -554,6 +557,9 @@
         }, {
         iterator: function () {
             return new Kotlin.RangeIterator(this.start, this.end, this.increment);
+        },
+        isEmpty: function() {
+            return this.increment > 0 ? this.start > this.end : this.start < this.end;
         }
     });
 

js/js.translator/testData/patternMatching/cases/doWhileWithOneStmWhen.kt

@@ -0,0 +1,15 @@
+package foo
+
+
+fun box(): Boolean {
+    var result = false
+    var i = 1
+    do
+        when (i) {
+            1 ->    result = true
+            else -> result = false
+        }
+    while (i==0)
+    return result;
+}
+

js/js.translator/testData/patternMatching/cases/forWithOneStmWhen.kt

@@ -0,0 +1,13 @@
+package foo
+
+
+fun box(): Boolean {
+    var result = false
+    for (i in array(1))
+        when (i) {
+            1 -> result = true
+            else -> result = false
+        }
+    return result;
+}
+

js/js.translator/testData/patternMatching/cases/ifWithOneStmWhen.kt

@@ -0,0 +1,13 @@
+package foo
+
+
+fun box(): Boolean {
+    var result = false
+    var i = 1
+    if (i==1)
+        when (i) {
+            1 ->    result = true
+            else -> result = false
+        }
+    return result;
+}

js/js.translator/testData/patternMatching/cases/whileWithOneStmWhen.kt

@@ -0,0 +1,14 @@
+package foo
+
+
+fun box(): Boolean {
+    var result = false
+    var i = 1
+    while(i==1)
+        when (i) {
+            1 -> { result = true; break }
+            else -> result = false
+        }
+    return result;
+}
+

libraries/stdlib/src/kotlin/JLangJVM.kt

@@ -24,9 +24,6 @@ public annotation class throws(vararg val exceptionClasses: Class<out Throwable>
 
 [Intrinsic("kotlin.javaClass.function")] fun <reified T> javaClass() : Class<T> = null as Class<T>
 
-Retention(RetentionPolicy.SOURCE)
-public annotation class volatile
-
 [Intrinsic("kotlin.synchronized")] public fun <R> synchronized(lock: Any, block: () -> R): R = block()
 
 public fun <T : Annotation> T.annotationType() : Class<out T> =

libraries/stdlib/src/kotlin/Ranges.kt

@@ -1,12 +1,21 @@
 package kotlin
 
-public data class ComparableRange<T: Comparable<T>> (
+public class ComparableRange<T: Comparable<T>> (
         public override val start: T,
         public override val end: T
 ): Range<T> {
-    public override fun contains(item: T): Boolean {
+    override fun contains(item: T): Boolean {
         return start <= item && item <= end
     }
+
+    override fun equals(other: Any?): Boolean {
+        return other is ComparableRange<*> && (isEmpty() && other.isEmpty() ||
+                start == other.start && end == other.end)
+    }
+
+    override fun hashCode(): Int {
+        return if (isEmpty()) -1 else 31 * start.hashCode() + end.hashCode()
+    }
 }
 
 public fun <T: Comparable<T>> T.rangeTo(that: T): ComparableRange<T> {

libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt

@@ -0,0 +1,33 @@
+/*
+ * 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 kotlin.jvm
+
+import java.lang.annotation.Retention
+import java.lang.annotation.RetentionPolicy
+
+Retention(RetentionPolicy.SOURCE)
+public annotation class volatile
+
+Retention(RetentionPolicy.SOURCE)
+public annotation class transient
+
+Retention(RetentionPolicy.SOURCE)
+public annotation class strictfp
+
+Retention(RetentionPolicy.SOURCE)
+public annotation class synchronized
+

libraries/stdlib/src/kotlin/text/Strings.kt

@@ -50,8 +50,8 @@ public val CharSequence.size: Int
 public val String.size: Int
     get() = length()
 
-public val String.indices : IntRange
+public val String.indices: IntRange
-    get() = 0..size
+    get() = 0..length() - 1
 
 /**
  * Returns a subsequence specified by given set of indices.
@@ -94,4 +94,4 @@ public fun Array<String>.join(separator: String = ", ", prefix: String = "", pos
  */
 public fun Stream<String>.join(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     return joinToString(separator, prefix, postfix, limit, truncated)
-}
+}

libraries/stdlib/test/language/RangeTest.kt

@@ -18,6 +18,8 @@ public class RangeTest {
 
         assertFalse(10 in range)
         assertFalse(9000 in range)
+        
+        assertFalse(range.isEmpty())
     }
 
     test fun byteRange() {
@@ -34,6 +36,8 @@ public class RangeTest {
 
         assertFalse(10.toByte() in range)
         assertFalse(111.toByte() in range)
+        
+        assertFalse(range.isEmpty())
     }
 
     test fun shortRange() {
@@ -50,22 +54,26 @@ public class RangeTest {
 
         assertFalse(10.toShort() in range)
         assertFalse(239.toShort() in range)
+        
+        assertFalse(range.isEmpty())
     }
 
     test fun longRange() {
-        val range = -5.toLong()..9.toLong()
+        val range = -5L..9L
-        assertFalse(-10000000.toLong() in range)
+        assertFalse(-10000000L in range)
-        assertFalse(-6.toLong() in range)
+        assertFalse(-6L in range)
 
-        assertTrue(-5.toLong() in range)
+        assertTrue(-5L in range)
-        assertTrue(-4.toLong() in range)
+        assertTrue(-4L in range)
-        assertTrue(0.toLong() in range)
+        assertTrue(0L in range)
-        assertTrue(3.toLong() in range)
+        assertTrue(3L in range)
-        assertTrue(8.toLong() in range)
+        assertTrue(8L in range)
-        assertTrue(9.toLong() in range)
+        assertTrue(9L in range)
 
-        assertFalse(10.toLong() in range)
+        assertFalse(10L in range)
-        assertFalse(10000000.toLong() in range)
+        assertFalse(10000000L in range)
+        
+        assertFalse(range.isEmpty())
     }
 
     test fun charRange() {
@@ -82,6 +90,8 @@ public class RangeTest {
 
         assertFalse('z' in range)
         assertFalse('\u1000' in range)
+        
+        assertFalse(range.isEmpty())
     }
 
     test fun doubleRange() {
@@ -100,24 +110,94 @@ public class RangeTest {
         assertFalse(3.15 in range)
         assertFalse(10.0 in range)
         assertFalse(1e200 in range)
+
+        assertFalse(range.isEmpty())
     }
 
     test fun floatRange() {
-        val range = -1.0.toFloat()..3.14159.toFloat()
+        val range = -1.0f..3.14159f
-        assertFalse(-1e30.toFloat() in range)
+        assertFalse(-1e30f in range)
-        assertFalse(-100.0.toFloat() in range)
+        assertFalse(-100.0f in range)
-        assertFalse(-1.00001.toFloat() in range)
+        assertFalse(-1.00001f in range)
 
-        assertTrue(-1.0.toFloat() in range)
+        assertTrue(-1.0f in range)
-        assertTrue(-0.99999.toFloat() in range)
+        assertTrue(-0.99999f in range)
-        assertTrue(0.0.toFloat() in range)
+        assertTrue(0.0f in range)
-        assertTrue(1.5.toFloat() in range)
+        assertTrue(1.5f in range)
-        assertTrue(3.1415.toFloat() in range)
+        assertTrue(3.1415f in range)
-        assertTrue(3.14159.toFloat() in range)
+        assertTrue(3.14159f in range)
 
-        assertFalse(3.15.toFloat() in range)
+        assertFalse(3.15f in range)
-        assertFalse(10.0.toFloat() in range)
+        assertFalse(10.0f in range)
-        assertFalse(1e30.toFloat() in range)
+        assertFalse(1e30f in range)
+
+        assertFalse(range.isEmpty())
+    }
+
+    test fun isEmpty() {
+        assertTrue((2..1).isEmpty())
+        assertTrue((2L..0L).isEmpty())
+        assertTrue((1.toShort()..-1.toShort()).isEmpty())
+        assertTrue((0.toByte()..-1.toByte()).isEmpty())
+        assertTrue((0f..-3.14f).isEmpty())
+        assertTrue((-2.72..-3.14).isEmpty())
+        assertTrue(('z'..'x').isEmpty())
+
+        assertTrue((1 downTo 2).isEmpty())
+        assertTrue((0L downTo 2L).isEmpty())
+        assertFalse((2 downTo 1).isEmpty())
+        assertFalse((2L downTo 0L).isEmpty())
+        assertTrue(('a' downTo 'z').isEmpty())
+        assertTrue(('z'..'a' step 2).isEmpty())
+
+        assertTrue(("range".."progression").isEmpty())
+    }
+
+    test fun emptyEquals() {
+        assertTrue(IntRange.EMPTY == IntRange.EMPTY)
+        assertEquals(IntRange.EMPTY, IntRange.EMPTY)
+        assertEquals(0L..42L, 0L..42L)
+        assertEquals(3 downTo 0, 3 downTo 0)
+
+        assertEquals(2..1, 1..0)
+        assertEquals(2L..1L, 1L..0L)
+        assertEquals(2.toShort()..1.toShort(), 1.toShort()..0.toShort())
+        assertEquals(2.toByte()..1.toByte(), 1.toByte()..0.toByte())
+        assertEquals(0f..-3.14f, 3.14f..0f)
+        assertEquals(-2.0..-3.0, 3.0..2.0)
+        assertEquals('b'..'a', 'c'..'b')
+
+        assertTrue(1 downTo 2 == 2 downTo 3)
+        assertTrue(-1L downTo 0L == -2L downTo -1L)
+        assertEquals(-1f downTo 1f, -2f downTo 2f)
+        assertEquals(-4.0 downTo -3.0, -2.0 downTo -1.0)
+        assertEquals('j'..'a' step 4, 'u'..'q' step 2)
+
+        assertFalse(0..1 == IntRange.EMPTY)
+        assertFalse(1f downTo 2f == 2f downTo 1f)
+
+        assertEquals("range".."progression", "hashcode".."equals")
+        assertFalse(("aa".."bb") == ("aaa".."bbb"))
+    }
+
+    test fun emptyHashCode() {
+        assertEquals((0..42).hashCode(), (0..42).hashCode())
+        assertEquals((1.23..4.56).hashCode(), (1.23..4.56).hashCode())
+
+        assertEquals((0..-1).hashCode(), IntRange.EMPTY.hashCode())
+        assertEquals((2L..1L).hashCode(), (1L..0L).hashCode())
+        assertEquals((0.toShort()..-1.toShort()).hashCode(), (42.toShort()..0.toShort()).hashCode())
+        assertEquals((0.toByte()..-1.toByte()).hashCode(), (42.toByte()..0.toByte()).hashCode())
+        assertEquals((0f..-3.14f).hashCode(), (2.39f..1.41f).hashCode())
+        assertEquals((0.0..-10.0).hashCode(), (10.0..0.0).hashCode())
+        assertEquals(('z'..'x').hashCode(), ('l'..'k').hashCode())
+
+        assertEquals((1 downTo 2).hashCode(), (2 downTo 3).hashCode())
+        assertEquals((1L downTo 2L).hashCode(), (2L downTo 3L).hashCode())
+        assertEquals((1.0 downTo 2.0).hashCode(), (2.0 downTo 3.0).hashCode())
+        assertEquals(('a' downTo 'b').hashCode(), ('c' downTo 'd').hashCode())
+
+        assertEquals(("range".."progression").hashCode(), ("hashcode".."equals").hashCode())
     }
 
     test fun comparableRange() {
@@ -131,5 +211,7 @@ public class RangeTest {
 
         assertFalse("item" in range)
         assertFalse("trail" in range)
+
+        assertFalse(range.isEmpty())
     }
 }

libraries/stdlib/test/language/RangeTestJVM.kt

@@ -15,7 +15,7 @@ public class RangeTestJVM {
     }
 
     test fun floatRange() {
-        val range = -1.0.toFloat()..3.14159.toFloat()
+        val range = -1.0f..3.14159f
         assertFalse(jFloat.NEGATIVE_INFINITY in range)
         assertFalse(jFloat.POSITIVE_INFINITY in range)
 
@@ -30,48 +30,48 @@ public class RangeTestJVM {
         failsWith(javaClass<IllegalArgumentException>()) { LongProgression(0, 5, 0) }
         failsWith(javaClass<IllegalArgumentException>()) { CharProgression('a', 'z', 0) }
         failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, 0.0) }
-        failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), 0.0.toFloat()) }
+        failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0f, 5.0f, 0.0f) }
 
         failsWith(javaClass<IllegalArgumentException>()) { 0..5 step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step 0  }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step 0.toLong() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0L..5L step 0L }
         failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step 0.0 }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step 0.0.toFloat() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0.0f..5.0f step 0.0f }
 
         failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step 0  }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step 0.toLong() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0L downTo -5L step 0L }
         failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step 0 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step 0.0 }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step 0.0.toFloat() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0.0f downTo -5.0f step 0.0f }
 
         failsWith(javaClass<IllegalArgumentException>()) { 0..5 step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step -2  }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step -2.toLong() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0L..5L step -2L }
         failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step -0.5 }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step -0.5.toFloat() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0.0f..5.0f step -0.5f }
 
         failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step -2  }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step -2.toLong() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0L downTo -5L step -2L }
         failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step -2 }
         failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step -0.5 }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step -0.5.toFloat() }
+        failsWith(javaClass<IllegalArgumentException>()) { 0.0f downTo -5.0f step -0.5f }
 
         // NaN increment or step
         failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, jDouble.NaN) }
-        failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), jFloat.NaN) }
+        failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0f, 5.0f, jFloat.NaN) }
 
         failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step jDouble.NaN }
-        failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step jFloat.NaN }
+        failsWith(javaClass<IllegalArgumentException>()) { 0.0f..5.0f step jFloat.NaN }
 
         failsWith(javaClass<IllegalArgumentException>()) { 5.0 downTo 0.0 step jDouble.NaN }
-        failsWith(javaClass<IllegalArgumentException>()) { 5.0.toFloat() downTo 0.0.toFloat() step jFloat.NaN }
+        failsWith(javaClass<IllegalArgumentException>()) { 5.0f downTo 0.0f step jFloat.NaN }
     }
 }

libraries/stdlib/test/text/StringTest.kt

@@ -62,4 +62,10 @@ class StringTest {
         assertEquals("4321", "1234".reverse())
         assertEquals("", "".reverse())
     }
+
+    test fun indices() {
+        assertEquals(0..4, "abcde".indices)
+        assertEquals(0..0, "a".indices)
+        assertEquals(IntRange.EMPTY, "".indices)
+    }
 }